echarts parseGeoJson 源码

echarts parseGeoJson 代码

文件路径：/src/coord/geo/parseGeoJson.ts

/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*/

/**
 * Parse and decode geo json
 */

import * as zrUtil from 'zrender/src/core/util';
import { GeoJSONLineStringGeometry, GeoJSONPolygonGeometry, GeoJSONRegion } from './Region';
import { GeoJSONCompressed, GeoJSON } from './geoTypes';


function decode(json: GeoJSONCompressed | GeoJSON): GeoJSON {
    if (!(json as GeoJSONCompressed).UTF8Encoding) {
        return json as GeoJSON;
    }
    const jsonCompressed = json as GeoJSONCompressed;
    let encodeScale = jsonCompressed.UTF8Scale;
    if (encodeScale == null) {
        encodeScale = 1024;
    }

    const features = jsonCompressed.features;
    zrUtil.each(features, feature => {
        const geometry = feature.geometry;
        const encodeOffsets = geometry.encodeOffsets;
        const coordinates = geometry.coordinates;

        // Geometry may be appeded manually in the script after json loaded.
        // In this case this geometry is usually not encoded.
        if (!encodeOffsets) {
            return;
        }

        switch (geometry.type) {
            case 'LineString':
                (geometry as any).coordinates =
                    decodeRing(coordinates as string, encodeOffsets as number[], encodeScale);
                break;
            case 'Polygon':
                decodeRings(coordinates as string[], encodeOffsets as number[][], encodeScale);
                break;
            case 'MultiLineString':
                decodeRings(coordinates as string[], encodeOffsets as number[][], encodeScale);
                break;
            case 'MultiPolygon':
                zrUtil.each(
                    coordinates as string[][],
                    (rings, idx) => decodeRings(rings, (encodeOffsets as number[][][])[idx], encodeScale)
                );
        }
    });
    // Has been decoded
    jsonCompressed.UTF8Encoding = false;

    return jsonCompressed as unknown as GeoJSON;
}

function decodeRings(
    rings: string[],
    encodeOffsets: number[][],
    encodeScale: number
) {
    for (let c = 0; c < rings.length; c++) {
        rings[c] = decodeRing(
            rings[c],
            encodeOffsets[c],
            encodeScale
        ) as any;
    }
}

function decodeRing(
    coordinate: string,
    encodeOffsets: number[],
    encodeScale: number
): number[][] {
    const result = [];
    let prevX = encodeOffsets[0];
    let prevY = encodeOffsets[1];

    for (let i = 0; i < coordinate.length; i += 2) {
        let x = coordinate.charCodeAt(i) - 64;
        let y = coordinate.charCodeAt(i + 1) - 64;
        // ZigZag decoding
        x = (x >> 1) ^ (-(x & 1));
        y = (y >> 1) ^ (-(y & 1));
        // Delta deocding
        x += prevX;
        y += prevY;

        prevX = x;
        prevY = y;
        // Dequantize
        result.push([x / encodeScale, y / encodeScale]);
    }

    return result;
}

export default function parseGeoJSON(geoJson: GeoJSON | GeoJSONCompressed, nameProperty: string): GeoJSONRegion[] {

    geoJson = decode(geoJson);

    return zrUtil.map(zrUtil.filter(geoJson.features, function (featureObj) {
        // Output of mapshaper may have geometry null
        return featureObj.geometry
            && featureObj.properties
            && featureObj.geometry.coordinates.length > 0;
    }), function (featureObj) {
        const properties = featureObj.properties;
        const geo = featureObj.geometry;

        const geometries = [] as GeoJSONRegion['geometries'];
        switch (geo.type) {
            case 'Polygon':
                const coordinates = geo.coordinates;
                // According to the GeoJSON specification.
                // First must be exterior, and the rest are all interior(holes).
                geometries.push(new GeoJSONPolygonGeometry(coordinates[0], coordinates.slice(1)));
                break;
            case 'MultiPolygon':
                zrUtil.each(geo.coordinates, function (item) {
                    if (item[0]) {
                        geometries.push(new GeoJSONPolygonGeometry(item[0], item.slice(1)));
                    }
                });
                break;
            case 'LineString':
                geometries.push(new GeoJSONLineStringGeometry([geo.coordinates]));
                break;
            case 'MultiLineString':
                geometries.push(new GeoJSONLineStringGeometry(geo.coordinates));

        }

        const region = new GeoJSONRegion(
            properties[nameProperty || 'name'],
            geometries,
            properties.cp
        );
        region.properties = properties;
        return region;
    });
}

相关信息

echarts 源码目录

相关文章

echarts Geo 源码

echarts GeoJSONResource 源码

echarts GeoModel 源码

echarts GeoSVGResource 源码

echarts Region 源码

echarts geoCreator 源码

echarts geoSourceManager 源码

echarts geoTypes 源码

echarts prepareCustom 源码