SuperMap iClient for Leaflet

                            npm install @supermap/iclient-leaflet
                        

                            import L from 'leaflet';
import {tiledMapLayer} from '@supermap/iclient-leaflet';

var url = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World";
var map = L.map('map', {
    crs: L.CRS.EPSG4326,
    center: [0, 0],
    maxZoom: 18,
    zoom: 1
});
tiledMapLayer(url).addTo(map);
                        

                            import L from 'leaflet';
import '@supermap/iclient-leaflet';

var url = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World";
var map = L.map('map', {
    crs: L.CRS.EPSG4326,
    center: [0, 0],
    maxZoom: 18,
    zoom: 1
});
L.supermap.tiledMapLayer(url).addTo(map);
                        

                            var L = require('leaflet');
var tiledMapLayer = require('@supermap/iclient-leaflet').tiledMapLayer;

var url = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World";
var map = L.map('map', {
    crs: L.CRS.EPSG4326,
    center: [0, 0],
    maxZoom: 18,
    zoom: 1
});
tiledMapLayer(url).addTo(map);
                        

                            var L = require('leaflet');
require('@supermap/iclient-leaflet');

var url = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World";
var map = L.map('map', {
    crs: L.CRS.EPSG4326,
    center: [0, 0],
    maxZoom: 18,
    zoom: 1
});
L.supermap.tiledMapLayer(url).addTo(map);
                        

                            module: {
        rules: [{
            // Load image files, encoding images Which are less than 80k with base64.
            test: /\.(png|jpg|jpeg|gif|woff|woff2|svg|eot|ttf)$/,
            use: [{
                loader: 'url-loader',
                options: {
                    limit: 80000
                }
            }]
        }, {
            // Load CSS files
            test: /\.css$/,
            use: ['css-loader']
        }, {
            // Use the babel-loader to convert ES6 syntax to ES5.
            test: /\.js$/,
            include: [
                path.resolve(__dirname, "node_modules/@supermap/iclient-common"),
                path.resolve(__dirname, "node_modules/@supermap/iclient-leaflet"),
                path.resolve(__dirname, "node_modules/elasticsearch"),
            ],
            loader: 'babel-loader',
            options: {
                presets: ['es2015']
            }
        }]
    }
                        

                                    
var crs = L.Proj.CRS("EPSG:4326", {
    origin: [114.59, 42.31],
    scaleDenominators: [100000, 50000, 25000, 20000, 10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 1]
});
map = L.map('map', {
    crs: crs,
    center: [39.79, 116.85],
});
L.supermap.tiledMapLayer(url).addTo(map);
                                        view source code »
                                    
                                

Proj4js.defs("EPSG:21418","+proj=tmerc +lat_0=0 +lon_0=105 +k=1 +x_0=18500000 +y_0=0 +ellps=krass +units=m +no_defs ");
                    

Proj4js.defs（"EPSG:10010"，"+title=Beijing1954 +proj=lcc +towgs84=0.0000,0.0000,0.0000 +a=6378245.0000 +rf=298.3 +lat_0=0.00000000 +lon_0=104.000000000 +lat_1=24.000000000 +lat_2=40.000000000 +x_0=0.000 +y_0=0.000 +units=m +no_defs"）;
                            

<!--[if lte IE 8]>
<script src="your shim js"></script>
<script src="your sham js"></script>
<![endif]-->
                            

                            //Initialize map information
var map = L.map('map', {
crs: L.CRS.EPSG4326,
    center: [40, 118],
    maxZoom: 18,
    zoom: 6
});
//initialize layer
var layerWorld = L.supermap.tiledMapLayer(DemoURL.world);
var layerJingjin = L.supermap.tiledMapLayer(DemoURL.jingjin_map, {
transparent: true,
    opacity: 0.6
});
//load layer
layerWorld.addTo(map);
layerJingjin.addTo(map);
                        

                            var measureParam = new SuperMap.MeasureParameters();
//Set the vector object ({line} or {Polygon}) to measure, and geometry can obtain via initialization
measureParam.geometry = geometry;
measureParam.unit = SuperMap.Unit.METER;
                        

                            var measureParam = new SuperMap.MeasureParameters();
//Set the vector object ({line} or {Polygon}) to measure, and geometry can obtain via initialization
measureParam.geometry = geometry;
measureParam.unit = SuperMap.Unit.METER;
                        

                            //Initialize the service class and set service request key parameters
var measureService = L.supermap.measureService(URL);
//Submit service request, pass service query parameters, get returned results and handle the results according to requirements
measureService.measureDistance(measureParam, function (serviceResult){
    function doSomething(serviceResult);
});
                        

                            function doSomething(serviceResult) {
    var distance = serviceResult.result.distance,
    unit = serviceResult.result.unit;
    var content = "Distance: " + distance + “ ”+unit;
    //Add pop up window at start point marker
    marker.bindPopup(content).openPopup(marker.getLatLng());
}
                        

                            //Initialize map
var url = "https://iserver.supermap.io/iserver/services/map-china400/wms111/China";
var map = L.map('map', {
center: [0, 0],
    maxZoom: 18,
    zoom: 1
});
//Initialize layer
var layer =L.tileLayer.wms(url, {
layers: 'China',
    format: 'image/png',
    transparent: true,
    noWrap: true,
});
//Load layer
layer.addTo(map);
                        

                            //Initialize map
//Resolution arrary information of the current layer
var res = [];
for (var i = 0; i < 22; i++) {
res.push(165664.43905455674 / (Math.pow(2, i)));
}
var map = L.map('map', {
    center: [0, 0],
    maxZoom: 18,
    zoom: 0,
    crs: L.Proj.CRS("EPSG:3857", '',
        {
            origin: [-2.0037508342789244E7, 2.0037508342789244E7],
            resolutions: res,
            bounds: L.bounds([-2.0037508342789244E7, -2.0037508342789244E7], [2.0037508342789244E7, 2.0037508342789244E7])
         })
});
//Initialize layer
var url = "https://iserver.supermap.io/iserver/services/map-china400/wmts100";
var layer = L.supermap.wmtsLayer(url,
{
layer: "China",
      style: "default",
      tilematrixSet: "Custom_China",
      format: "image/png"
   });
//Load layer
layer.addTo(map);
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World";
var map = L.map('map', {
preferCanvas: true,
    crs: L.CRS.EPSG4326,
    center: [20, 80],
    maxZoom: 18,
    zoom: 2
});
L.supermap.tiledMapLayer(baseUrl).addTo(map).on("load", function () {
query();
});
//Handle dataset ID query
function query() {
//Dataset ID query service parameters
    var idsParam = new SuperMap.GetFeaturesByIDsParameters({
        IDs: [246, 247],
        datasetNames: ["World:Countries"]
    });
    //Send the request to the server and handle the results returned from the server
var url = "https://iserver.supermap.io/iserver/services/data-world/rest/data";
    L.supermap.featureService(url).getFeaturesByIDs(idsParam, function (serviceResult) {
        L.geoJSON(serviceResult.result.features, {
            onEachFeature: function (feature, layer) {
                //Add pop up event for the results
                layer.bindPopup("ID: " + feature.properties.SMID +
"<br>" + "Country: " + feature.properties.COUNTRY);
             }}).addTo(map);
    });
}
                            
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World",
var map = L.map('map', {
preferCanvas: true,
    crs: L.CRS.EPSG4326,
    center: [0, 0],
    maxZoom: 18,
    zoom: 1
});
L.supermap.tiledMapLayer(baseUrl).addTo(map).on("load", function () {
query();
});
//Handle dataset SQL query
function query() {
//Dataset SQL query service parameters
    var sqlParam = new SuperMap.GetFeaturesBySQLParameters({
        queryParameter: {
                name: "Countries@World",
                attributeFilter: "SMID = 247"
        },
        datasetNames: ["World:Countries"]
    });
    //Send the request to the server and handle the results returned from the server
var url = "https://iserver.supermap.io/iserver/services/data-world/rest/data";
    L.supermap.featureService(url).getFeaturesBySQL(sqlParam, function (serviceResult) {
        //Display results on the map and add pop up window for the results
        L.geoJSON(serviceResult.result.features).addTo(map).bindPopup('SMID = 247');
    });
}

                            
                        

                            //Buffer analysis parameters
dsBufferAnalystParams = new SuperMap.DatasetBufferAnalystParameters({
//The dataset name in the datasource used for buffer analysis
   dataset: "RoadLine2@Changchun",
//Set the filter condition for feature set in the dataset
   filterQueryParameter: new SuperMap.FilterParameter({
//Attribute filter condition
       attributeFilter: "NAME='Tuanjie Road'"
   }),
//Set buffer analysis common parameters
   bufferSetting: new SuperMap.BufferSetting({
//Set end type, including FLAT and RROUND
       endType: SuperMap.BufferEndType.ROUND,
//Left radius
       leftDistance: {value: 10},
//Right radius
       rightDistance: {value: 10},
//Set the number of line segments for round buffer
       semicircleLineSegment: 10
   })
});
                            
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
crs: L.CRS.NonEarthCRS({
        bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
        origin: L.point(48.4, -55.58)
    }),
    center: [-3375, 5105],
    maxZoom: 18,
    zoom: 6
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
    bufferAnalystProcess();
});
//Define buffer analysis service
function bufferAnalystProcess(){
var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst"
var bufferServiceByDatasets = L.supermap.spatialAnalystService(serviceUrl);
//Send the request to the server and display the results returned from the server on the map
bufferServiceByDatasets.bufferAnalysis(dsBufferAnalystParams,function(serviceResult)
{
        var result = serviceResult.result;
        resultLayer = L.geoJSON(result.recordset.features, {color: "red"})
resultLayer.addTo(map);
});
}
                            
                        

                            //Set overlay analysis parameters
var dsOverlayAnalyParams = new SuperMap.DatasetOverlayAnalystParameters({
      sourceDataset: "BaseMap_R@Jingjin",  //The name of the source dataset of overlay analysis
      operateDataset: "Neighbor_R@Jingjin",  //The name of the operate dataset of overlay analysis
      tolerance: 0,  //Tolerance
      operation: SuperMap.OverlayOperationType.UNION  //The type of overlay analysis
});
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-jingjin/rest/maps/JingjinPopulationDistribution_ThematicMap",
var map = L.map('map', {
        crs: L.CRS.EPSG4326,
        center: [40.05, 116.85],
        maxZoom: 18,
        zoom: 6
});
L.supermap.tiledMapLayer(baseUrl, { transparent: true, cacheEnabled: false, noWrap: true}).addTo(map) .on("load", function () {
        overlayAnalystProcess();
});
//Define overlay analysis service
function overlayAnalystProcess() {
var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst";
var overlayAnalystService = L.supermap.spatialAnalystService(serviceUrl);
//Send the request to the server and display the results returned from the server on the map
overlayAnalystService.overlayAnalysis(dsOverlayAnalyParams, function(serviceResult) {
    var result = serviceResult.result;
    var resultLayer = L.geoJSON(result.recordset.features)
resultLayer.addTo(map);
);
}
                            
                        

                            //Set clip area
var region = L.polygon([[4010338,0],[4010338,1063524],[3150322,1063524],[3150322,0]]);
//Set surface analysis parameters
var extractParams = new SuperMap.SurfaceAnalystParametersSetting({
datumValue: 0, //The datum value in surface analysis
    interval: 2, //The interval value
    resampleTolerance: 0, //The resample tolerance
    smoothMethod: SuperMap.SmoothMethod.BSPLINE, //The method used for smoothing
    smoothness: 3, //The smoothness of contour lines
    clipRegion: region //The clip object
});
//The surface analysis parameters
var surfaceAnalystParams = new SuperMap.DatasetSurfaceAnalystParameters({
extractParameter: extractParams, //The surface analysis parameters
    dataset: "SamplesP@Interpolation", //The name of the source dataset in overlay analysis
    resolution: 3000, //The resoluton of intermediate results
    zValueFieldName: "AVG_TMP" //The name of the field used for extraction
});
                            
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-temperature/rest/maps/ChinaTemperatureMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([-2640403.63, 1873792.1], [3247669.39, 5921501.4]),
            origin: L.point(-2640403.63, 5921501.4)
        }),
        center: [3580330, 531762],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
        surfaceAnalystProcess();
});
//Process surface analysis service
function surfaceAnalystProcess() {
    //Initialize surface analysis service instance
var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst" ;
var surfaceAnalystService = L.supermap.spatialAnalystService(serviceUrl);
//Send the request to the server and process the resullts
surfaceAnalystService.surfaceAnalysis(surfaceAnalystParams, function (serviceResult) {
L.geoJSON(serviceResult.result.recordset.features, {weight: 3}).addTo(map);
});
}
                            
                        

                            //Configure dynamic segmentation parameters
var generateSpatialDataParams = new SuperMap.GenerateSpatialDataParameters({
            routeTable: "RouteDT_road@Changchun",//Route dataset
            routeIDField: "RouteID",//The route ID
            eventTable: "LinearEventTabDT@Changchun",//The event table used to generate spatial data
            eventRouteIDField: "RouteID",//The route ID of the event table used to generate spatial data
            measureField: "",//The measure field of the event table used to generate spatial data
            measureStartField: "LineMeasureFrom",//The from field of the event table
            measureEndField: "LineMeasureTo",//The to field of the event table
            measureOffsetField: "",//The offset field for measure values
            errorInfoField: "",//The error message field
//Set DataReturnOption
            dataReturnOption: new SuperMap.DataReturnOption({
//Set the maximum number of records allowed to be returned
                  expectCount: 1000,
//Set result dataset identification. Because dataReturnMode is set to SuperMap.REST.DataReturnMode.DATASET_ONLY, only the name of the dataset will be returned
                  dataset: "generateSpatialData@Changchun",
//If the user-named result dataset name is the same as the existing dataset, delete the existing data set
                  deleteExistResultDataset: true,
//Set the data return mode to DATASET_ONLY
                  dataReturnMode: SuperMap.DataReturnMode.DATASET_ONLY
            })
});
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangechunCityMap",
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3861.911472192499, 4700],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
        generateSpatialDataAnalystProcess();
});
//Configure dynamic segmentation service
function generateSpatialDataAnalystProcess(){
    var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst"
var generateSpatialDataService = L.supermap.spatialAnalystService(serviceUrl);
//Send the request to the server and display the results on the client side as thematic map
generateSpatialDataService.generateSpatialData(generateSpatialDataParams, function () {
        //Display the results on the client side as thematic map
        showAnalysisResult_ThemeGridUnique();
});
//When the data is returned, it will be displayed on the client side as thematic map
function showAnalysisResult_ThemeGridUnique() {
        //Create a thematic map instance
        themeService = L.supermap.themeService(baseUrl);
        //Configure thematic map styles
        var style1, style2, style3;
        style1 = new SuperMap.ServerStyle({
            fillForeColor: new SuperMap.ServerColor(242, 48, 48),
            lineColor: new SuperMap.ServerColor(242, 48, 48),
            lineWidth: 1
        });
        style2 = new SuperMap.ServerStyle({
            fillForeColor: new SuperMap.ServerColor(255, 159, 25),
            lineColor: new SuperMap.ServerColor(255, 159, 25),
            lineWidth: 1
        });
        style3 = new SuperMap.ServerStyle({
            fillForeColor: new SuperMap.ServerColor(91, 195, 69),
            lineColor: new SuperMap.ServerColor(91, 195, 69),
            lineWidth: 1
        });
        //Configure thematic map items
        var themeUniqueIteme1, themeUniqueIteme2, themeUniqueIteme3;
        themeUniqueIteme1 = new SuperMap.ThemeUniqueItem({
            unique: "Blocked",
            style: style1
        });
        themeUniqueIteme2 = new SuperMap.ThemeUniqueItem({
            unique: "Congested",
            style: style2
        });
        themeUniqueIteme3 = new SuperMap.ThemeUniqueItem({
            unique: "Expedite",
            style: style3
        });
        var themeUnique = new SuperMap.ThemeUnique({
            uniqueExpression: "TrafficStatus",
            defaultStyle: new SuperMap.ServerStyle({
                fillForeColor: new SuperMap.ServerColor(48, 89, 14),
                lineColor: new SuperMap.ServerColor(48, 89, 14)
            }),
            items: [themeUniqueIteme1, themeUniqueIteme2, themeUniqueIteme3]
        });
        themeParameters = new SuperMap.ThemeParameters({
            themes: [themeUnique],
            datasetNames: ["generateSpatialData"],
            dataSourceNames: ["Changchun"]
        });
        themeService.getThemeInfo(themeParameters, function (serviceResult1) {
            var result = serviceResult1.result;
            if (result && result.newResourceID) {
                themeLayer = L.supermap.tiledMapLayer(baseUrl, {
                    noWrap: true,
                    cacheEnabled: false,
                    transparent: true,
                    layersID: result.newResourceID
                    //opacity: 0.8
                }).addTo(map);
            }
        });
}
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
crs: L.CRS.NonEarthCRS({
        bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
        origin: L.point(48.4, -55.58)
    }),
    center: [-3861.91, 4503.62],
    maxZoom: 18,
    zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map) .on("load", function () {
    routeCalculateMeasureProcess();
});
                            
                        

                            function routeCalculateMeasureProcess() {
    //Set SQL query parameters
    var queryBySQLParams = new SuperMap.QueryBySQLParameters({
queryParams: [
            new SuperMap.FilterParameter({
                name: "RouteDT_road@Changchun",
                attributeFilter: "RouteID=1690"
            })
         ]
    });
//Create SQL service
    var queryBySQLService = L.supermap.queryService(baseUrl);
    //Send the request to the server and handle the results returned from the server
    queryBySQLService.queryBySQL(queryBySQLParams, function (serviceResult) {
        var resultLayer = L.geoJSON(serviceResult.result.recordsets[0].features,
{color: "red"}).addTo(map);
        //Extract the points that form the route to construct the parameter sourceRoute
        var pointsList = [];
        var routeObj = serviceResult.result.recordsets[0].features.features[0].geometry.coordinates[0];
        for (var i = 0; i < routeObj.length; i++) {
            pointsList.push([routeObj[i][1], routeObj[i][0],routeObj[i][2]])
        }
        routeLine = L.polyline(pointsList);
        //Select one query point (the 8th point in the array) from the points that compose the route and add it to the map
        var marker= L.circleMarker([routeObj[7][1], routeObj[7][0]],
{radius: 3, color: 'black'}).addTo(map);
        //Create routeCalculateMeasureService
        var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst";
        var routeCalculateMeasureService = L.supermap.spatialAnalystService(serviceUrl);
        //Set parameters
var routeCalculateMeasureParameters = new SuperMap.RouteCalculateMeasureParameters({
            "sourceRoute": routeLine,Route Type
            "point": L.point(routeObj[7][0], routeObj[7][1]),//Query point
            "tolerance": 10,
            "isIgnoreGap": false
        });
        //Send the request to the server and handle the results returned from the server routeCalculateMeasureService.routeCalculateMeasure ( routeCalculateMeasureParameters, function (serviceResult) {
           //Add pop up window for the query results and display the obtained M value
           marker.bindTooltip("The M value obtained is: " + serviceResult.result.measure + "", {direction:"top",offset:L.point(0,-5)}).openTooltip();
           });
        });
}
                            
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
    crs: L.CRS.NonEarthCRS({
        bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
        origin: L.point(48.4, -55.58)
    }),
    center: [-3861.91, 4503.62],
    maxZoom: 18,
    zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map) .on("load", function () {
    routeLocatorProcess();
});
                            
                        

                            function routeLocatorProcess() {
    //Set SQL query service parameters
    queryBySQLParams = new SuperMap.QueryBySQLParameters({
        queryParams: [
            new SuperMap.FilterParameter({
                name: "RouteDT_road@Changchun",
                attributeFilter: "RouteID=1690"
            })
         ]
     });
    //Create query service
    var queryBySQLService = L.supermap.queryService(baseUrl);
    //Send the request to the server, handle the results returned from the server, and display the handled results on the map
    queryBySQLService.queryBySQL(queryBySQLParams, function (serviceResult) {
        var resultLayer = L.geoJSON(serviceResult.result.recordsets[0].features,
{color: "red"}).addTo(map);
        //Extract the points that form the route to construct polyline of sourceRoute
        var pointsList = [];
        var routeObj = serviceResult.result.recordsets[0].features.features[0].geometry.coordinates[0];
        for (var i = 0; i < routeObj.length; i++) {
            pointsList.push([routeObj[i][1], routeObj[i][0], routeObj[i][2]])
        }
        var routeLine = L.polyline(pointsList);
//Handle Route Locator Point service
//Set Route Locator Point parameters
    var routeLocatorParams_point = new SuperMap.RouteLocatorParameters({
        "sourceRoute": routeLine, //The route object
        "type": "POINT", //Type, point or line
        "measure": 200, //M value
        "offset": 0, //Offset
        "isIgnoreGap": true //Whether to ignore distance between child objects
    });
//Create spatial analysis service
var serviceUrl =
"https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst";
var routeLocatorService = L.supermap.spatialAnalystService(serviceUrl);
    //Send the request to the server and display the results on the client side after handling
    routeLocatorService.routeLocate(routeLocatorParams_point, function (serviceResult) {
        var layer=L.geoJSON(serviceResult.result.resultGeometry).addTo(map);
        //Add pop up window
        layer.bindTooltip("Point with M value " + routeLocatorParams_point.measure + " found" , {direction:"top", offset:L.point(0,-5)}).openTooltip();
        });
    });
}
                            
                        

                            //Initialize map, and add event for the map
var baseUrl =
"https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap",
var map = L.map('map', {
crs: L.CRS.NonEarthCRS({
        bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
        origin: L.point(48.4, -55.58)
    }),
    center: [-3861.91, 4503.62],
    maxZoom: 18,
    zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map) .on("load", function () {
    routeLocatorProcess();
});
                            
                        

                            function routeLocatorProcess () {
    //Set SQL query service parameters
    queryBySQLParams = new SuperMap.QueryBySQLParameters({
        queryParams: [
            new SuperMap.FilterParameter({
                name: "RouteDT_road@Changchun",
                attributeFilter: "RouteID=1690"
            })
         ]
     });
    //Create query service
    var queryBySQLService = L.supermap.queryService(baseUrl);
    //Send the request to the server, handle the results returned from the server, and display the handled results on the map
    queryBySQLService.queryBySQL(queryBySQLParams, function (serviceResult) {
        var resultLayer = L.geoJSON(serviceResult.result.recordsets[0].features,
{color: "red"}).addTo(map);
        //Extract the points that form the route to construct polyline of sourceRoute
        var pointsList = [];
        var routeObj = serviceResult.result.recordsets[0].features.features[0].geometry.coordinates[0];
        for (var i = 0; i < routeObj.length; i++) {
            pointsList.push([routeObj[i][1], routeObj[i][0], routeObj[i][2]])
        }
        var routeLine = L.polyline(pointsList);
//Handle Route Locator Line
//Set Route Locator Line parameters
    var routeLocatorParams_line = new SuperMap.RouteLocatorParameters({
        "sourceRoute": routeLine, //The route object
        "type": "LINE", //Type, point or line
        "startMeasure": 10, //The from value of the line
        "endMeasure": 800, //The to value of the line
        "isIgnoreGap": true //Whether to ignore distance between child objects
    });
//Create spatial analysis service
var serviceUrl =
"https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst";
var routeLocatorService = L.supermap.spatialAnalystService(serviceUrl);
    //Send the request to the server and display the results on the client side after handling
    routeLocatorService.routeLocate(routeLocatorParams_line, function (serviceResult) {
        var resultLayer1 = L.geoJSON(serviceResult.result.resultGeometry).addTo(map);
    })
}
                            
                        

                            //Traffic network analysis result parameters
var resultSetting = new SuperMap.TransportationAnalystResultSetting({
       returnEdgeFeatures: true, //Whether to include edge collection in the results
       returnEdgeGeometry: true, //Whether to include collection object information in the returned edge feature collection
       returnEdgeIDs: true, //Whether to include ID collection of passed edges in the returned results
       returnNodeFeatures: true, //Whether to include node feature collection in the returned results
       returnNodeGeometry: true, //Whether to include collection object information in the returned node feature collection
       returnNodeIDs: true, //Whether to include ID collection of passed nodes in the returned results
       returnPathGuides: true, //Whether to include path guides collection in the returned results
       returnRoutes: true//Whether to include route object collection in the returned results
});
//Traffic network analysis common parameters
var analystParameter = new SuperMap.TransportationAnalystParameter({
         resultSetting: resultSetting, //The contents of the analysis results
         weightFieldName: "length"//Name of the impedance field
});
//Optimal path analysis parameters
var findPathParams = new SuperMap.FindPathParameters({
         isAnalyzeById: false, //Whether to specify route analysis nodes by node ID
//The array of nodes or facility points passed in optimal path analysis
         nodes: [L.latLng(-3000, 4000), L.latLng(-2500, 5500), L.latLng(-4000, 6900)],
         hasLeastEdgeCount: false, //Whether to perform optimal path analysis according to least edges
         parameter: analystParameter//Traffic network analysis common parameters
});
                            
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3600, 5000],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
        findPathProcess();
});
//Define optimal path analysis service
function findPathProcess(){
    //Add stops
var marker1 = L.marker([-3000, 4000]).addTo(map);
marker1.bindPopup("Stop 1");
var marker2 = L.marker([-2500, 5500]).addTo(map);
marker2.bindPopup("Stop 2");
var marker3 = L.marker([-4000, 6900]).addTo(map);
marker3.bindPopup("Stop 3");
    //Set icon
    var myIcon = L.icon({
            iconUrl: "https://iserver.supermap.io/iserver/iClient/forJavaScript/examples/images/walk.png",
            iconSize: [20, 20]
    });
    var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
    var findPathService = L.supermap.networkAnalystService(serviceUrl);
    //Send the request to the server and display the results on the client side after handling and analysis
    findPathService.findPath(findPathParams, function (serviceResult) {
            var result = serviceResult.result;
            result.pathList.map(function (result) {
                L.polyline(result.route).addTo(map);
                L.geoJSON(result.pathGuideItems, {
                    pointToLayer: function (geoPoints, latlng) {
                        L.marker(latlng, {icon: myIcon}).addTo(map);
                    }
                }).addTo(map);
            })
    });
}
                            
                        

                            //Add center points
var marker = L.marker([-3375, 5605]).addTo(map);
//Traffic network analysis result parameters
var resultSetting = new SuperMap.TransportationAnalystResultSetting({
returnEdgeFeatures: true,//Whether to include edge collection in the results
      returnEdgeGeometry: true,//Whether to include collection object information in the returned edge feature collection
      returnEdgeIDs: true,//Whether to include ID collection of passed edges in the returned results
      returnNodeFeatures: true,//Whether to include node feature collection in the returned results
      returnNodeGeometry: true,//Whether to include collection object information in the returned node feature collection
      returnNodeIDs: true,//Whether to include ID collection of passed nodes in the returned results
      returnPathGuides: true,//Whether to include path guides collection in the returned results
      returnRoutes: true//Whether to include route object collection in the returned results
};
//Traffic network analysis common parameters
var analystParameter = new SuperMap.TransportationAnalystParameter({
resultSetting: resultSetting,//The contents of the analysis results
      weightFieldName: "length"//Name of the impedance field
});
var findServiceAreasParams = new SuperMap.FindServiceAreasParameters({
centers: [marker.getLatLng()],//Service stop array
    isAnalyzeById: false,//Whether to specify route analysis nodes by node ID
    parameter: analystParameter,//Traffic network analysis common parameters
    weights: weightsArray//The impedance radius of each stop to provide service
});
                            
                        

                            //Initialize map, and add event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3500, 5200],
        maxZoom: 18,
        zoom: 3
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
        findServiceAreas();
});
//Define service area analysis service
function findServiceAreas() {
        var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
        var service = L.supermap.networkAnalystService(serviceUrl);
var resultLayer = L.featureGroup().addTo(map);
        parameter.weights = [400 + Math.random() * 100];
        //Send the request to the server and handle the results returned from the server
        service.findServiceAreas(findServiceAreasParams, function (serviceResult) {
              var result = serviceResult.result;
              result.serviceAreaList.map(function (serviceArea) {
                  resultLayer.addLayer(L.geoJSON(serviceArea.serviceRegion));
              });
        });
}
                            
                        

                            //Traffic network analysis result parameters
var resultSetting = new SuperMap.TransportationAnalystResultSetting({
returnEdgeFeatures: true,//Whether to include edge collection in the results
    returnEdgeGeometry: true,//Whether to include collection object information in the returned edge feature collection
    returnEdgeIDs: true,//Whether to include ID collection of passed edges in the returned results
    returnNodeFeatures: true,//Whether to include node feature collection in the returned results
    returnNodeGeometry: true,//Whether to include collection object information in the returned node feature collection
    returnNodeIDs: true,//Whether to include ID collection of passed nodes in the returned results
    returnPathGuides: true,//Whether to include path guides collection in the returned results
    returnRoutes: true//Whether to include route object collection in the returned results
};
//Traffic network analysis common parameters
var analystParameter = new SuperMap.TransportationAnalystParameter({
resultSetting: resultSetting,//The contents of the analysis results
    weightFieldName: "length"//Name of the impedance field
});
var findTSPPathsParams = new SuperMap.FindTSPPathsParameters ({
isAnalyzeById: false,//Whether to specify passed nodes by Node ID
nodes: nodeArray,//The array of passed nodes for travelling salesman analysis. The array can be array of coordinates or IDs of points
endNodeAssigned: false,//Whether to specify termination point
    parameter: analystParameter//Traffic network analysis common parameters
});
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3600, 4700],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
                findTSPPathsProcess();
});
//Multiple travelling salesmen analysis
function findTSPPathsProcess() {
        //Add stops
        var myIcon = L.icon({
            iconUrl: "https://iserver.supermap.io/iserver/iClient/forJavaScript/theme/images/marker.png",
            iconSize: [44, 30]
        });
        var marker4 = L.marker([-1000, 3000], {icon: myIcon}).addTo(map);
        var marker5 = L.marker([-4850, 3760], {icon: myIcon}).addTo(map);
        var marker6 = L.marker([-2700, 8000], {icon: myIcon}).addTo(map);
        //Add pop up windows for supply centers
        marker4.bindPopup("Retail Stop 1");
        marker5.bindPopup("Retail Stop 2");
        marker6.bindPopup("Retail Stop 3");
        //Create multiple travelling salesmen analysis service instance
        var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
        var findTSPPathsService = L.supermap.networkAnalystService(serviceUrl);
//Send the request to the server and handle the results returned
        findTSPPathsService.findTSPPaths(findTSPPathsParams, function (serviceResult) {
            var result = serviceResult.result;
            result.tspPathList.map(function (result) {
                L.geoJSON(result.route).addTo(map);
            });
        });
}
                            
                        

                            //Traffic network analysis result parameters
var resultSetting = new SuperMap.TransportationAnalystResultSetting({
returnEdgeFeatures: true,//Whether to include edge collection in the results
      returnEdgeGeometry: true,//Whether to include collection object information in the returned edge feature collection
      returnEdgeIDs: true,//Whether to include ID collection of passed edges in the returned results
      returnNodeFeatures: true,//Whether to include node feature collection in the returned results
      returnNodeGeometry: true,//Whether to include collection object information in the returned node feature collection
      returnNodeIDs: true,//Whether to include ID collection of passed nodes in the returned results
      returnPathGuides: true,//Whether to include path guides collection in the returned results
      returnRoutes: true//Whether to include route object collection in the returned results
};
//Traffic network analysis common parameters
var analystParameter = new SuperMap.TransportationAnalystParameter({
      resultSetting: resultSetting,//Contents of the returned results
      turnWeightField: "TurnCost",//Name of the turn weight field
      weightFieldName: "length" //Name of the impedance field
});
//Closest facility analysis parameters
var findClosetFacilitiesParams = new SuperMap.FindClosestFacilitiesParameters({
      //Event point, which is generally the position of the event where facility service is required
      event: L.latLng(-3700, 5000),
      //The number of facility number to be queried
      expectFacilityCount: 1,
      //Facility point collection, which is generally the collection of positions of facilities that offer the service
      facilities: [L.latLng(-3500, 2500), L.latLng(-2500, 5500), L.latLng(-4000, 7000)],
      //Whether the event point and facility points are specified by Node IDs
isAnalyzeById: false,
//Traffic network analysis common parameters
      parameter: analystParameter
});
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3600, 4700],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on('load', function () {
        findClosetFacilitiesProcess();
});
//Set closest facility analysis service
function findClosetFacilitiesProcess(){
        //Add facility points
        var marker1 = L.marker([-3500, 2500]).addTo(map);
        marker1.bindPopup("Facility point 1");
        var marker2 = L.marker([-2500, 5500]).addTo(map);
        marker2.bindPopup("Facility point 2");
        var marker3 = L.marker([-4000, 7000]).addTo(map);
        marker3.bindPopup("Facility point 3");
        //Add event points
        var myIcon = L.icon({
            iconUrl: "https://iserver.supermap.io/iserver/iClient/forJavaScript/theme/images/marker.png",
            iconSize: [44, 30]
        });
        var marker4 = L.marker([-3700, 5000], {icon: myIcon}).addTo(map);
        marker4.bindPopup("Event point");
//Create closest facility analysis service instance
var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
var findClosetFacilitiesService = L.supermap.networkAnalystService(serviceUrl);
//Send request to the server and handle the returned results
findClosetFacilitiesService.findClosestFacilities(findClosetFacilitiesParams, function (serviceResult) {
            var rersult = serviceResult.result;
            rersult.facilityPathList.map(function (result) {
                resultLayer = L.geoJSON(result.route).addTo(map);
            });
        });
}
                            
                        

                            //Resource center type, which can be fixed or optional
var supplyCenterType_FIXEDCENTER = SuperMap.SupplyCenterType.FIXEDCENTER,
var supplyCenterType_NULL = SuperMap.SupplyCenterType.NULL,
var supplyCenterType_OPTIONALCENTER = SuperMap.SupplyCenterType.OPTIONALCENTER;
var supplyCenters=[new SuperMap.REST.SupplyCenter({
maxWeight: 500,//The max cost of resource supply center
    nodeID: 139,//The node ID of resource supply center
    resourceValue: 100,//The maximum amount of service or quantity of goods a resource supply center can provide
    type: supplyCenterType_OPTIONALCENTER//Type of resource center
}),
    new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 1358,
        resourceValue: 100,
        type: supplyCenterType_OPTIONALCENTER

    }),
    new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 2972,
        resourceValue: 100,
        type: supplyCenterType_OPTIONALCENTER
    }),
    new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 5523,
        resourceValue: 100,
        type: supplyCenterType_OPTIONALCENTER
   }),
   new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 1161,
        resourceValue: 100,
        type: supplyCenterType_OPTIONALCENTER
   }),
   new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 4337,
        resourceValue: 100,
        type: supplyCenterType_OPTIONALCENTER
}),
    new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 5732,
        resourceValue: 100,
        type: supplyCenterType_NULL
    }),
    new SuperMap.SupplyCenter({
        maxWeight: 500,
        nodeID: 663,
        resourceValue: 100,
        type: supplyCenterType_FIXEDCENTER
    })
];
//Create FindLocationParameters instance
var findLocationParams = new SuperMap.FindLocationParameters({
     expectedSupplyCenterCount: 8, //Number of resource centres expected
     isFromCenter: false, //Whether to start allocating resources from supply center
     nodeDemandField: "Demand", //Node demand field
     turnWeightField: "TurnCost", //Turn weight field
     weightName: "length", //Name of the impedance field
     supplyCenters: supplyCenters //Supply center collection, required
});
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3600, 4700],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
        findLocationProcess();
});
//Handle location allocation servie results
function findLocationProcess() {
        //Add facility points
        L.marker([-593.56822512495194, 1675.9256791377206]).addTo(map);
        L.marker([-2358.0414663985171, 2820.35101097629]).addTo(map);
        L.marker([-3647.0074300836109, 2909.4396668115278]).addTo(map);
        L.marker([-5616.5950974905827, 1544.5037476378677]).addTo(map);
        L.marker([-2130.4887600981415, 6623.5972101719526]).addTo(map);
        L.marker([-4504.2328567816048, 5482.4979617984973]).addTo(map);
        L.marker([-1627.6012900626256, 6940.6579024271468]).addTo(map);
        L.marker([-5747.5063918659716, 8215.9188781715948]).addTo(map);
//Create location allocation analysis service instance
var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
        var findLocationService = L.supermap.networkAnalystService(serviceUrl);
//Send request to the server and handle the returned results
        findLocationService.findLocation(findLocationParams, function (serviceResult) {
                    L.geoJSON(serviceResult.result.demandResults, {
                        pointToLayer: function (geoJsonPoint, latlng) {
                            return L.circleMarker(latlng, {radius: 1, color: "green"});
                        }
                    }).addTo(map);
                });
}
                            
                        

                            //Traffic network analysis result parameters
var resultSetting = new SuperMap.TransportationAnalystResultSetting({
returnEdgeFeatures: true,//Whether to include edge collection in the results
    returnEdgeGeometry: true,//Whether to include collection object information in the returned edge feature collection
    returnEdgeIDs: true,//Whether to include ID collection of passed edges in the returned results
    returnNodeFeatures: true,//Whether to include node feature collection in the returned results
    returnNodeGeometry: true,//Whether to include collection object information in the returned node feature collection
    returnNodeIDs: true,//Whether to include ID collection of passed nodes in the returned results
    returnPathGuides: true,//Whether to include path guides collection in the returned results
    returnRoutes: true//Whether to include route object collection in the returned results
};
//Traffic network analysis common parameters
var analystParameter = new SuperMap.TransportationAnalystParameter({
resultSetting: resultSetting,//The contents of the analysis results
    weightFieldName: "length"//Name of the impedance field
});
//Multiple travelling salesmen analysis parameters
var findMTSPPathsParams = new SuperMap.FindMTSPPathsParameters({
//Supply center collection
centers: [L.latLng(-5500, 6000), L.latLng(-2500, 5500), L.latLng(-3500, 2500)],
//Whether to specify supply centers and destinations via node ID
isAnalyzeById: false,
//Supply destination collection
nodes: [L.latLng(-5000, 5000), L.latLng(-2800, 8000)],
//Whether the distribution mode is Least Total Cost
    hasLeastTotalCost: true,
//Traffic network analysis common parameters
    parameter: analystParameter
});
                            
                        

                            //Initialize map, and set event for the map
var baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap";
var map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3600, 4700],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map).on("load", function () {
        findMTSPPathsProcess();
});
//Handle multipel travelling salemen analysis results
 function findMTSPPathsProcess() {
        //Add distribution centers
        var marker1 = L.marker([-5500, 6000]).addTo(map);
        var marker2 = L.marker([-2500, 5500]).addTo(map);
        var marker3 = L.marker([-3500, 2500]).addTo(map);
        //Add pop up windows for supply centers
        marker1.bindPopup("Distribution center 1");
        marker2.bindPopup("Distribution center 2");
        marker3.bindPopup("Distribution center 3");
        //Add destinations
        var myIcon = L.icon({
            iconUrl: 'https://iserver.supermap.io/iserver/iClient/forJavaScript/theme/images/marker.png',
            iconSize: [44, 30]
        });
        var marker4 = L.marker([-5000, 5000], {icon: myIcon}).addTo(map);
        var marker5 = L.marker([-2800, 8000], {icon: myIcon}).addTo(map);
        //Add pop up windows for supply centers
        marker4.bindPopup("Destination 1");
        marker5.bindPopup("Destination 2");
        //Create multipel travelling salemen analysis service instance
        var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
        var findMTSPPathsService = L.supermap.networkAnalystService(serviceUrl);
        //Send the request to the server and handle the returned results
        findMTSPPathsService.findMTSPPaths(findMTSPPathsParams, function (serviceResult) {
            var result = serviceResult.result;
            result.pathList.map(function (result) {
                L.geoJSON(result.route, {color: "green"}).addTo(map);
            });
        });
}
                            
                        

                            var map, startMarker, endMarker, tempRedLayer, tempMarker,
   routeFeatureGroup, paths = {transSolutions: null, solutions: null}, info,
   baseUrl = "https://iserver.supermap.io/iserver/services/map-changchun/rest/maps/ChangchunCityMap",
   serviceUrl = "https://iserver.supermap.io/iserver/services/traffictransferanalyst-sample/restjsr/traffictransferanalyst/Traffic-Changchun";
//Initialize map
map = L.map('map', {
        crs: L.CRS.NonEarthCRS({
            bounds: L.bounds([48.4, -7668.25], [8958.85, -55.58]),
            origin: L.point(48.4, -55.58)
        }),
        center: [-3900, 4700],
        maxZoom: 18,
        zoom: 2
});
L.supermap.tiledMapLayer(baseUrl, {noWrap: true}).addTo(map);
//Set start point
startMarker = L.marker([-5527.73795456, 3111.42533851]).addTo(map)
.bindTooltip("Start point", {
        offset: L.point([0, -10]),
        direction: "top",
        permanent: true
}).openTooltip();
//Set end point
endMarker = L.marker([-4270.0725196, 6055.3431955]).addTo(map)
.bindTooltip("End point", {
         offset: L.point([0, -10]),
         direction: "top",
         permanent: true
}).openTooltip();
routeFeatureGroup = L.featureGroup().addTo(map); //Establish temporary stop layer
tempRedLayer = L.featureGroup().addTo(map); //Establish temporary bus line layer
initResultInfoWin();  //Initialize message box
execTransSolutionsQuery('LESS_TIME'); //Least transfer time query

//Initialize message box
function initResultInfoWin() {
        info = L.control({position: 'topright'});  //Display the message box at the top rigt corner
        info.onAdd = function () {
            this._div = L.DomUtil.create('div', 'panel panel-primary');
            info.update();
            handleMapEvent(this._div, this._map);
            return this._div;
        };
        //Map event
        function handleMapEvent(div, map) {
            if (!div || !map) {
                return;
            }
            div.addEventListener('mouseover', function () {
                map.dragging.disable();
                map.scrollWheelZoom.disable();
                map.doubleClickZoom.disable();
            });
            div.addEventListener('mouseout', function () {
                map.dragging.enable();
                map.scrollWheelZoom.enable();
                map.doubleClickZoom.enable();
            });
        }
        //Message box content update
        info.update = function (transSolutions, transGuide) {
            if (!transSolutions) {
                return;
            }
            var solution, lines, line, dispStatus = "block";
            $("<div class='panel-heading' style='background:steelblue;color: honeydew'>Start point: Auto Repair Shop      End point: Zhongan Mansion<br/>Transfer Solution (Least Time)</div>").appendTo(this._div);
            for (var i = 0, iLen = transSolutions.length; i < iLen; i++) {
                solution = transSolutions[i];
                //Display solution
                var title = "";
                for (var ii = 0, iiLen = solution.linesItems.length; ii < iiLen; ii++) {
                    lines = solution.linesItems[ii];
                    for (var iii = 0, iiiLen = lines.lineItems.length; iii < iiiLen; iii++) {
                        line = lines.lineItems[iii];
                        if (iii !== iiiLen - 1) {
                            title += line.lineName + "/";
                        } else {
                            title += line.lineName;
                        }
                    }
                    if (ii !== iiLen - 1) {
                        title += " → ";
                    }
                }
                $("<div class='transferSolution' id='transferSolution-" + i + "'><span class='transferIndex'>Solution " + (i + 1) + "：</span>" + title + "</div>").appendTo(this._div);
                if (i !== 0) {
                    dispStatus = "none";
                }
                var list = $("<div class='transferInfo' id='transferInfo-" + i + "' style='display:" + dispStatus + "'></div>");
                list.appendTo(this._div);
                //Display table of solution 1 by default
                if (i === 0) {
                    fillTransferInfo(transGuide, transSolutions, 0).appendTo(list);
                    setPopup();
                }
            }
            //Display the corresponding table while clicking a solution
            bindSolutionsClickEvent();
        };
        info.addTo(map);
}
//Display table of solution indexX
function fillTransferInfo(transGuide, transSolutions, indexX) {
        clearLayer();
        if (transGuide && transGuide.items.length) {
            var items = transGuide.items;
            for (var itemIndex = 0, itemLen = items.length; itemIndex < itemLen; itemIndex++) {
                var geometry = items[itemIndex].route;
                routeFeatureGroup.addLayer(L.geoJSON(L.Util.toGeoJSON(geometry)).addTo(map));
            }
        }
        var table = $("<table id='trafficRes' border='1'></table>");
        var startStop = $("<tr></tr>");
        $("<td class='start_transfer' width='10px'></td>").appendTo(startStop);
        $("<td colspan='2'><span class='busLink bgSpan'><span style='display:none'>" + transGuide.items[0].startPosition.x + "," + transGuide.items[0].startPosition.y + "</span>" + transGuide.items[0].startStopName + "</span></td>").appendTo(startStop);
        startStop.appendTo(table);
        var indexY = 0;
        for (var iiii = 0, iiiiLen = transGuide.items.length; iiii < iiiiLen; iiii++) {
            var item = transGuide.items[iiii];
            var tr2 = $("<tr></tr>");
            if (item.isWalking) {
                $("<td class='step_transfer' ></td>").appendTo(tr2);
                $("<td> Walk to: <a class='busLink'><span style='display:none'>" + item.endPosition.x + "," + item.endPosition.y + "</span>" + item.endStopName + "</a></td>").appendTo(tr2);
                $("<td>" + parseInt(item.distance) + " m </td>").appendTo(tr2);
            } else {
                var otherLines = transSolutions[indexX].linesItems[indexY],
                    links = "";
                if (otherLines && otherLines.lineItems.length > 1) {
                    links = "</br> or take: "
                    for (var oti = 0, otLen = otherLines.lineItems.length; oti < otLen; oti++) {
                        var line = otherLines.lineItems[oti];
                        if (item.lineName !== line.lineName) {
                            var other = indexX + "," + indexY + "," + oti + ",0";
                            links += "<a class='busLink'><span style='display:none'>" + other + "</span>" + line.lineName + "</a>";
                        }
                    }
                }
                $("<td class='bus_transfer'></td>").appendTo(tr2);
                var points = item.route.points, pointStr = "";
                for (var i = 0; i < points.length; i++) {
                    pointStr += points[i].x + " " + points[i].y;
                    if (i != points.length - 1) {
                        pointStr += ",";
                    }
                }
                $("<td> Take <a class='busLink'>" + item.lineName + "<span style='display:none'>" + pointStr + "</span></a>, at <a class='busLink'><span style='display:none'>" + item.endPosition.x + "," + item.endPosition.y + "</span>" + item.endStopName + "</a> Get off " + links + "</td>").appendTo(tr2);
                $("<td>" + item.passStopCount + " stop </td>").appendTo(tr2);
                indexY++;
            }
            tr2.appendTo(table);
        }
        var endStop = $("<tr></tr>");
        endStop.appendTo(table);
        $("<td class='end_transfer' width='10px'></td>").appendTo(endStop);
        $("<td colspan='2'><span class='busLink bgSpan'><span style='display:none'>" + transGuide.items[transGuide.items.length - 1].endPosition.x + "," + transGuide.items[transGuide.items.length - 1].endPosition.y + "</span>" + transGuide.items[transGuide.items.length - 1].endStopName + "</span></td>").appendTo(endStop);
        return table;
}

//Define execTransSolutionsQuery
function execTransSolutionsQuery(tactic) {
    //Clear results of the previous solution
    info.remove();
    paths.points = [26, 180];
//Configure TransferSolutionParameters
    var params = new SuperMap.TransferSolutionParameters({
            solutionCount: 6,//The maximum transfer guide count
            transferTactic: tactic,//Type of bus transfer strategy
            walkingRatio: 10,//Weight ratio of walking and bus consumption
            points: paths.points //Starting point coordinates
    });
var serviceUrl = "https://iserver.supermap.io/iserver/services/traffictransferanalyst-sample/restjsr/traffictransferanalyst/Traffic-Changchun";
//Send the request to the server and handle the results returned from the server
    L.supermap.trafficTransferAnalystService(serviceUrl)
            .analysisTransferSolution(params, function (serviceResult) {
                if (serviceResult.error) {
                    alert("Error: " + serviceResult.error.errorMsg);
                }
                transferSolutionsSucceed(serviceResult.result);
     });
}

//The returned results when implemented successfully
function transferSolutionsSucceed(result) {
        clearLayer();
        info.addTo(map);
        //Overlay symbol information on the map
//transGuide：Records the traffic transfer guidance scheme from the starting point to the terminating point
//transGuide is composed of objects of the TransferGuideItem type
//Each TransferGuideItem can be a transfer segment or walking route. The type of object can return the number of items in transGuide
//The total distance and cost can be guided according to TransferGuideItem
//transSolutions: The transfer times are the same in all bus routes within a transfer scheme.
        var transGuide = result.defaultGuide,
            transSolutions = result.solutionItems,
            solutions = [];
        for (var j = 0; j < transSolutions.length; j++) {
            var linesItems = transSolutions[j].linesItems, transSolution = [];
            for (var jj = 0; jj < linesItems.length; jj++) {
                var lineItems = linesItems[jj].lineItems, items = [];
                for (var jjj = 0; jjj < lineItems.length; jjj++) {
                    var lineItem = lineItems[jjj];
                    items.push("{'lineID':" + lineItem.lineID +
                        ",'startStopIndex':" + lineItem.startStopIndex +
                        ",'endStopIndex':" + lineItem.endStopIndex + "}"
                    );
                }
                transSolution.push(items);
            }
            solutions.push(transSolution);
        }
        paths["transSolutions"] = transSolutions;
        paths["solutions"] = solutions;
        if (!transGuide || !transSolutions) return;
        info.update(transSolutions, transGuide);
}

//Clear all result layers
function clearLayer() {
        if (routeFeatureGroup) {
            routeFeatureGroup.clearLayers();
        }
        if (tempRedLayer) {
            tempRedLayer.clearLayers();
        }
        if (tempMarker) {
            tempMarker.remove();
        }
}
                            
                        

                            //Click on a solution to get a specific route
function bindSolutionsClickEvent() {
        for (var i = 0; i < 6; i++) {
            $("#transferSolution-" + i).click(toggleGuideItems);
        }
        function toggleGuideItems(e) {
            for (var j = 0; j < 6; j++) {
                $("#transferInfo-" + j).hide(500);
            }
            var id = parseInt(e.currentTarget.id.split("-")[1]);
            $("#transferInfo-" + id).show(500);
            //Construct transferLines passed into iServer
            var transLines = [];
            for (var i = 0; i < paths.solutions[id].length; i++) {
                var trans = paths.solutions[id][i][0];
                transLines.push(trans);
            }
            execTransPathQuery(id, transLines);
        }
}

//Get detailed information about the bus route
function execTransPathQuery(id, transLines) {
//Set bus route parameters
        var params = new SuperMap.TransferPathParameters({
            points: paths["points"], //Starting point coordinates
            transferLines: transLines //Current transfer route, including Route ID, starting and ending points, etc.
        });
        //Send the request to the server and handle the results returned from the server
        L.supermap.trafficTransferAnalystService(serviceUrl)
            .analysisTransferPath(params, function (serviceResult) {
                $("#transferInfo-" + id).empty();
                var transGuide = serviceResult.result;
                transSolutions = paths["transSolutions"];
                map.setView([-3900, 4700], 2);
                fillTransferInfo(transGuide, transSolutions, id)
.appendTo($("#transferInfo-" + id));
                setPopup();
            });
}

//Show the temporary stops and routes queried on the map
function setPopup() {
        $(".busLink").click(function () {
            tempRedLayer.clearLayers(); //Clear the temporary route layer
            if (tempMarker) tempMarker.remove();  //Clear the temporary stop layer
            var points = this.children[0].innerText.split(","), lonLat;
            if (points.length === 2) {
                lonLat = L.latLng(points[1], points[0]);
                tempMarker = L.marker(lonLat).addTo(map);
                map.setView(lonLat);
            } else if (points.length === 4 && points[3] === "0") {
                var linesItems = paths["solutions"][points[0]], lineStr = "[";
                for (var i = 0; i < linesItems.length; i++) {
                    var lineItem = linesItems[i][0], j = parseInt(points[1]);
                    if (i !== j) {
                        lineStr += lineItem;
                    } else if (i === j) {
                        lineItem = linesItems[points[1]][points[2]];
                        lineStr += lineItem;
                    }
                    if (i !== linesItems.length - 1) {
                        lineStr += ",";
                    }
                }
                lineStr += "]";
                $("#transferInfo-" + points[0]).hide(500);
                execTransPathQuery(points[0], lineStr);
                $("#transferInfo-" + points[0]).show(500);
            } else {
                var linePoints = [];
                for (var i = 0; i < points.length; i++) {
                    var arr = points[i].split(" ");
                    var point = [arr[1], arr[0]];
                    linePoints.push(point);
                }
                var lineString = L.polyline(linePoints, {color: "red"}).addTo(map);
                tempRedLayer.addLayer(lineString);
                map.setView(lineString.getBounds().getCenter(), 3);
            }
        });
}
                            
                        

                            //Density analysis parameters
var kernelDensityJobParams = new SuperMap.KernelDensityJobParameter({
//Name of the registered dataset
datasetName: "newyork_taxi_2013_01_14k_csv_newyork_taxi_2013-01_14k",
//Grid size. For the quadrilateral, it is the grid length. For hexagonal meshes, it is the distance from the hexagonal vertex to the center point
    resolution: 80,
//Analysis method, specify whether the analysis method is simple point density analysis, or kernel density analysis. 0 represents the former, and 1 represents the latter
    method:0,
//Grid surface type, specify whether the grid unit is a quadrilateral grid or a hexagonal grid. 0 represents the former, and 1 represents the latter
    meshType:0,
//Specifies the field index column number collection of the weight value of the points to be analyzed, and the field index starts at 0. The format is as follows: col7, col8
    fields: col7,col8,
    query: Bounds, //Analysis bounds
    radius: 300, //The impact radius of the analysis
    meshSizeUnit: Meter, //Grid size unit
radiusUnit: Meter, //Search radius unit
    areaUnit: SquareMile, //Area unit
});
                            
                        

                            //Initialize map
var map = L.map('map', {
crs: L.CRS.TianDiTu_WGS84,
    center: [40.75, -73.95],
    maxZoom: 18,
    zoom: 12
}),
//Add Tianditu layer on the map
L.supermap.tiandituTileLayer("http://t{s}.tianditu.com/vec_c/wmts", {
    layer: "vec",
    tilematrixSet: "c"
}).addTo(map);

//Create distributed analysis service
var processingUrl ="http://localhost:8090/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new L.supermap.processingService(processingUrl);
//Submit the request for kernel analysis to the server, parse the results returned from the server, and display the results on the map.
processingService.addKernelDensityJob(kernelDensityJobParams, function (serviceResult) {
//Pop a warning box and display error message for parsing failure
if (serviceResult.error) {
        var errorMsg = serviceResult.error.errorMsg || "code: " + serviceResult.error.code;
        showAlert("Create failure! 
" + errorMsg, false);
        return;
    }
    //Process the results and display the results on map if the analysis is successful
    serviceResult.result.setting.serviceInfo.targetServiceInfos.map(function (info) {
        if (info.serviceType === 'RESTMAP') {
            SuperMap.FetchRequest.get(info.serviceAddress + '/maps')
.then(function(response) {return response.json();}).then(function (result) {
var mapUrl = result[0].path;
    var layer = L.supermap.imageMapLayer(mapUrl, {noWrap: true, transparent: true});
    layer.addTo(map);
             });
          }
    });
});
                            
                        

                            //Point aggregation analysis parameters
var summaryMeshJobParam = new SuperMap.SummaryMeshJobParameter({
//Name of the registered dataset
datasetName: "newyork_taxi_2013_01_14k_csv_newyork_taxi_2013-01_14k",
//Grid size. For the quadrilateral, it is the grid length. For hexagonal meshes, it is the distance from the hexagonal vertex to the center point
    resolution: 80,
//Grid surface type, specify whether the grid unit is a quadrilateral grid or a hexagonal grid. 0 represents the former, and 1 represents the latter
    meshType:0,
//Specifies the field index column number collection of the weight value of the points to be analyzed, and the field index starts at 0. The format is as follows: col7, col8
    fields: col7,
    query: Bounds, //Analysis bounds
    statisticModes:,//Statistics mode, which needs to be consistent with the number of weight value fields
    type:, SummaryType//Aggregation type, specifies whether the aggregation type is a grid surface aggregation or polygon aggregation.
    //regionDataset: 'regionDataset', Aggregation surface dataset, used during polygon aggregation
});
                            
                        

                            //Initialize map
var map = L.map('map', {
crs: L.CRS.TianDiTu_WGS84,
    center: [40.75, -73.95],
    maxZoom: 18,
    zoom: 12
}),
//Add Tianditu layer on the map
L.supermap.tiandituTileLayer("http://t{s}.tianditu.com/vec_c/wmts", {
    layer: "vec",
    tilematrixSet: "c"
}).addTo(map);

//Create distributed analysis service
var processingUrl ="http://localhost:8090/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new L.supermap.processingService(processingUrl);
//Submit the request for point aggregation analysis to the server, parse the results returned from the server, and display the results on the map.
processingService.addSummaryMeshJob(summaryMeshJobParam,function(serviceResult){
//Pop a warning box and display error message for parsing failure
if (serviceResult.error) {
        var errorMsg = serviceResult.error.errorMsg || "code: " + serviceResult.error.code;
        showAlert("Create failure! 
" + errorMsg, false);
        return;
    }
    //Process the results and display the results on map if the analysis is successful
    serviceResult.result.setting.serviceInfo.targetServiceInfos.map(function (info) {
        if (info.serviceType === 'RESTMAP') {
            SuperMap.FetchRequest.get(info.serviceAddress + '/maps')
.then(function(response) {return response.json();}).then(function (result) {
var mapUrl = result[0].path;
    var layer = L.supermap.imageMapLayer(mapUrl, {noWrap: true, transparent: true});
    layer.addTo(map);
             });
          }
    });
});
                            
                        

                            //Single object query analysis parameters
var singleObjectQueryJobsParam = new SuperMap.SingleObjectQueryJobsParameter({
datasetName: 'ProcessingData_processing_newyorkZone_R', //Name of the registered dataset
datasetQuery: 'ProcessingData_processing_singleRegion_R', //Name of the dataset where the query objects are
mode:SpatialQueryMode //Spatial query mode
});
                            
                        

                            //Initialize map
var map = L.map('map', {
crs: L.CRS.TianDiTu_WGS84,
    center: [40.75, -73.95],
    maxZoom: 18,
    zoom: 12
}),
//Add Tianditu layer on the map
L.supermap.tiandituTileLayer("http://t{s}.tianditu.com/vec_c/wmts", {
    layer: "vec",
    tilematrixSet: "c"
}).addTo(map);

//Create distributed analysis service
var processingUrl ="http://localhost:8090/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new L.supermap.processingService(processingUrl);
//Submit the request for single object query analysis to the server, parse the results returned from the server, and display the results on the map.
processingService.addQueryJob(singleObjectQueryJobsParam,function(serviceResult){
//Pop a warning box and display error message for parsing failure
if (serviceResult.error) {
        var errorMsg = serviceResult.error.errorMsg || "code: " + serviceResult.error.code;
        showAlert("Create failure! 
" + errorMsg, false);
        return;
    }
    //Process the results and display the results on map if the analysis is successful
    serviceResult.result.setting.serviceInfo.targetServiceInfos.map(function (info) {
        if (info.serviceType === 'RESTMAP') {
            SuperMap.FetchRequest.get(info.serviceAddress + '/maps')
.then(function(response) {return response.json();}).then(function (result) {
var mapUrl = result[0].path;
    var layer = L.supermap.imageMapLayer(mapUrl, {noWrap: true, transparent: true});
    layer.addTo(map);
             });
          }
    });
});
                            
                        

                            //Region summary analysis parameters
var summaryRegionJobParam = new SuperMap.SummaryRegionJobParameter({
datasetName: 'ProcessingData_processing_newyorkZone_R', //Name of the registered dataset
    //regionDataset: 'regionDataset', Aggregation region dataset, used during polygon aggregation
    type: SummaryType, //Summary type, which can be grid surface summary and polygon summary
//Grid surface type, specify whether the grid unit is a quadrilateral grid or a hexagonal grid. 0 represents the former, and 1 represents the latter
    meshType:0,
    query: Bounds, //Analysis bounds
    standardSummaryFields: true, //Whether to do statistics based on standard attribute field
    //The statistical mode while doing statistics based on standard attribute field
    standardStatisticModes: StatisticAnalystMode,
    standardFields: "LocationID", //The field name when while doing statistics based on standard attribute field
    weightedFields:false, //Whether to do statistics based on weight field
    weightedStatisticModes: "", //The statistical mode while doing statistics based on weight field
weightedSummaryFields: "",//The field name while doing statistics based on weight field
//Grid size. For the quadrilateral, it is the grid length. For hexagonal meshes, it is the distance from the hexagonal vertex to the center point
    resolution:100,
    meshSizeUnit: Meter, //Grid size unit
    sumShape:true //Whether to do statistics on length or area
});
                            
                        

                            //Initialize map
var map = L.map('map', {
crs: L.CRS.TianDiTu_WGS84,
    center: [40.75, -73.95],
    maxZoom: 18,
    zoom: 12
}),
//Add Tianditu layer on the map
L.supermap.tiandituTileLayer("http://t{s}.tianditu.com/vec_c/wmts", {
    layer: "vec",
    tilematrixSet: "c"
}).addTo(map);

//Create distributed analysis service
var processingUrl ="http://localhost:8090/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new L.supermap.processingService(processingUrl);
//Submit the request for region summary analysis to the server, parse the results returned from the server, and display the results on the map.
processingService.addSummaryRegionJob(summaryRegionJobParam,
function(serviceResult){
//Pop a warning box and display error message for parsing failure
if (serviceResult.error) {
        var errorMsg = serviceResult.error.errorMsg || "code: " + serviceResult.error.code;
        showAlert("Create failure! 
" + errorMsg, false);
        return;
    }
    //Process the results and display the results on map if the analysis is successful
    serviceResult.result.setting.serviceInfo.targetServiceInfos.map(function (info) {
        if (info.serviceType === 'RESTMAP') {
            SuperMap.FetchRequest.get(info.serviceAddress + '/maps')
.then(function(response) {return response.json();}).then(function (result) {
var mapUrl = result[0].path;
    var layer = L.supermap.imageMapLayer(mapUrl, {noWrap: true, transparent: true});
    layer.addTo(map);
             });
          }
    });
});
                            
                        

                            //Vector clip analysis parameters
var vectorClipJobsParam = new SuperMap.VectorClipJobsParameter({
datasetName: 'ProcessingData_newyork_taxi_2013-01_14k', //Name of the registered dataset
    datasetOverlay: 'ProcessingData_processing_singleRegion_R',//Name of the dataset where the clip object is
    mode:ClipAnalystMode //Clip analysis mode
});
                            
                        

                            //Initialize map
var map = L.map('map', {
crs: L.CRS.TianDiTu_WGS84,
    center: [40.75, -73.95],
    maxZoom: 18,
    zoom: 12
}),
//Add Tianditu layer on the map
L.supermap.tiandituTileLayer("http://t{s}.tianditu.com/vec_c/wmts", {
    layer: "vec",
    tilematrixSet: "c"
}).addTo(map);

//Create distributed analysis service
var processingUrl ="http://localhost:8090/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new L.supermap.processingService(processingUrl);
//Submit the request for vector clip analysis to the server, parse the results returned from the server, and display the results on the map.
processingService.addVectorClipJob(vectorClipJobsParam, function(serviceResult){
//Pop a warning box and display error message for parsing failure
if (serviceResult.error) {
        var errorMsg = serviceResult.error.errorMsg || "code: " + serviceResult.error.code;
        showAlert("Create failure! 
" + errorMsg, false);
        return;
    }
    //Process the results and display the results on map if the analysis is successful
    serviceResult.result.setting.serviceInfo.targetServiceInfos.map(function (info) {
        if (info.serviceType === 'RESTMAP') {
            SuperMap.FetchRequest.get(info.serviceAddress + '/maps')
.then(function(response) {return response.json();}).then(function (result) {
var mapUrl = result[0].path;
    var layer = L.supermap.imageMapLayer(mapUrl, {noWrap: true, transparent: true});
    layer.addTo(map);
             });
          }
    });
});
                            
                        

                            //Create real time data layer
var urlDataFlow = "ws://localhost:8091/iserver/services/dataflow/dataflow";
var dataFlowLayer = L.supermap.dataFlowLayer(urlDataFlow, {
    //Optional, elements within the GeoJSON filter will be returned
geometry:{coordinates:[[[116.38,39.87],[116.41,39.87],[116.41,39.84],[116.38, 39.84],[116.38,39.87]]],type:"Polygon"},
//Optional, return excluded fields
    excludeField:["id"],
//Optional, return feature coordinate system
	 prjCoordSys:4326
 });
 dataFlowLayer.addTo(map);
                            
                        

                            //Initialize map
var baseUrl = 'https://iserver.supermap.io/iserver/services/map-china400/rest/maps/China_4326';
var map = L.map('map', {
crs: L.CRS.EPSG4326,
    center: [39.914714, 116.383572],
    maxZoom: 18,
    zoom: 11
});
L.supermap.tiledMapLayer(baseUrl).addTo(map);
//Forward matching parameters
var geoCodeParam = new SuperMap.GeoCodingParameter({
address: "SuperMap", //Address
    fromIndex:0, //Min index
    toIndex:10, //Max index
    filters: "Company", //Filter condition
    prjCoordSys:{epsgcode26}, //Set coordinates
    maxReturn:3 //Max results
});
//Createm address matching service
var addressUrl = "https://iserver.supermap.io/iserver/services/addressmatch-Address/restjsr/v1/address",
var addressMatchService = L.supermap.addressMatchService(addressUrl);
//Send request to the server to operate forward address matching. The server will return the results and the results will be handled
addressMatchService.code(geoCodeParam, match);
//Handle the results and display the results on the map and add pop up window
function match(obj) {
obj.result.map(function (item) {
        var marker = L.marker([item.location.y, item.location.x]);
        decodeMarkers.push(marker);
        var innerHTML = "";
        innerHTML += "Address:" + item.address + "<br>";
        var x = Number(item.location.x.toString().match(/^\d+(?:\.\d{0,2})?/));
        var y = Number(item.location.y.toString().match(/^\d+(?:\.\d{0,2})?/));
        innerHTML += "Coordinates:[" + x + "," + y + "]<br>";
        if (item.score > 0) {
            innerHTML += "Matching rate:" + item.score + "<br>";
        }
        innerHTML += "Filter field:" + item.filters + "<br>";
            marker.bindPopup(innerHTML);
        });
        for (var i = 0; i < decodeMarkers.length; i++) {
            decodeMarkers[i].addTo(map);
        }
        map.setView(L.latLng(39.914714, 116.383572), 10);//Set map display bounds
}
                            
                        

                            //Initialize map
var baseUrl = 'https://iserver.supermap.io/iserver/services/map-china400/rest/maps/China_4326';
var map = L.map('map', {
crs: L.CRS.EPSG4326,
    center: [39.914714, 116.383572],
    maxZoom: 18,
    zoom: 11
});
L.supermap.tiledMapLayer(baseUrl).addTo(map);
//Reverse matching parameters
var geoDecodeParam = new SuperMap.GeoDecodingParameter({
x:116.3518541194, //X coordinate
y:40.00097839595, //Y coordinate
    fromIndex:0, //Min index
    toIndex:10, //Max index
    filters: "", //Filter field
    prjCoordSys:{epsgcode26}, //Set coordinates
    maxReturn:3, //Max results
geoDecodingRadius:1000 //Search radius
});
//Create address matching service
var addressUrl = "https://iserver.supermap.io/iserver/services/addressmatch-Address/restjsr/v1/address",
var addressMatchService = L.supermap.addressMatchService(addressUrl);
//Send request to the server to operate forward address matching. The server will return the results and the results will be handled
addressMatchService.decode(geoDecodeParam, match);
//Handle the results and display the results on the map and add pop up window
function match(obj) {
obj.result.map(function (item) {
        var marker = L.marker([item.location.y, item.location.x]);
        decodeMarkers.push(marker);
        var innerHTML = "";
        innerHTML += "Addresss:" + item.address + "<br>";
        var x = Number(item.location.x.toString().match(/^\d+(?:\.\d{0,2})?/));
        var y = Number(item.location.y.toString().match(/^\d+(?:\.\d{0,2})?/));
        innerHTML += "Coordinates:[" + x + "," + y + "]<br>";
        if (item.score > 0) {
            innerHTML += "Matching rate:" + item.score + "<br>";
        }
        innerHTML += "Filter field:" + item.filters + "<br>";
            marker.bindPopup(innerHTML);
        });
        for (var i = 0; i < decodeMarkers.length; i++) {
            decodeMarkers[i].addTo(map);
        }
        map.setView(L.latLng(39.914714, 116.383572), 10);//Set map display bounds
}