amap-shapes-generator/lib/index.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
exports.__esModule = true;
var reselect_1 = require("reselect");
var Common_1 = require("./Common");
var Utils_1 = require("./Utils");
exports.latLngDegreesToDecimal = Utils_1.latLngDegreesToDecimal;
exports.latLngDecimalToDegrees = Utils_1.latLngDecimalToDegrees;
var LatLon = require('geodesy').LatLonSpherical;
function convertAirspaceInfoServerToLocal(airspaceInfo) {
    var airspaceType = airspaceInfo.airspace_type;
    if (airspaceType == Common_1["default"].airspaceType.circle) {
        var ai = airspaceInfo;
        return {
            airspaceType: airspaceType,
            airspaceId: ai.airspace_id,
            name: ai.airspace_name,
            note: ai.note,
            addr: ai.center_loc,
            lat: Utils_1.latLngDecimalToDegrees(ai.center_point_of_flying.lat),
            lng: Utils_1.latLngDecimalToDegrees(ai.center_point_of_flying.lng),
            radius: ai.radius_of_flying,
            height: ai.altitude + "",
            heightStandard: Common_1["default"].heightStandardsById.get(ai.unit)
        };
    }
    if (airspaceType == Common_1["default"].airspaceType.line) {
        var ai = airspaceInfo;
        var dep = {
            addr: ai.start_loc,
            lat: Utils_1.latLngDecimalToDegrees(ai.start_point.lat),
            lng: Utils_1.latLngDecimalToDegrees(ai.start_point.lng),
            height: ai.start_point.altitude + "",
            heightStandard: Common_1["default"].heightStandardsById.get(ai.start_point.unit)
        };
        var arrive = {
            addr: ai.end_loc,
            lat: Utils_1.latLngDecimalToDegrees(ai.end_point.lat),
            lng: Utils_1.latLngDecimalToDegrees(ai.end_point.lng)
        };
        var passPoints = [];
        if (Array.isArray(ai.passing_points)) {
            for (var _i = 0, _a = ai.passing_points; _i < _a.length; _i++) {
                var obj = _a[_i];
                var point = void 0;
                if (obj.point_type == Common_1["default"].pointTypes.point) {
                    var pp = obj;
                    var lat = Utils_1.latLngDecimalToDegrees(pp.lat);
                    var lng = Utils_1.latLngDecimalToDegrees(pp.lng);
                    point = {
                        pointType: pp.point_type,
                        addr: pp.point_name,
                        lat: lat, lng: lng
                    };
                }
                else if (obj.point_type == Common_1["default"].pointTypes.nav) {
                    var pp = obj;
                    var lat = Utils_1.latLngDecimalToDegrees(pp.lat);
                    var lng = Utils_1.latLngDecimalToDegrees(pp.lng);
                    point = {
                        pointType: pp.point_type,
                        pointId: pp.point_id,
                        pointCode: pp.point_code,
                        pointName: pp.point_name,
                        lat: lat, lng: lng
                    };
                }
                else {
                    var pp = obj;
                    point = {
                        pointType: pp.point_type,
                        airRouteId: pp.airway,
                        airlineCode: pp.air_route_code,
                        airlines: pp.points
                    };
                }
                if (Utils_1.isNumber(obj.altitude) && Utils_1.isNumber(obj.unit)) {
                    point.height = obj.altitude + "";
                    point.heightStandard = Common_1["default"].heightStandardsById.get(obj.unit);
                }
                else {
                    point.height = "";
                    point.heightStandard = Common_1["default"].heightStandards.keys().slice()[0];
                }
                passPoints.push(point);
            }
        }
        return __assign({
            airspaceType: airspaceType,
            airspaceId: ai.airspace_id,
            name: ai.airspace_name,
            note: ai.note,
            dep: dep,
            arrive: arrive,
            passPoints: passPoints
        }, (ai.airline_width ? { airlineWidth: ai.airline_width } : {}));
    }
    if (airspaceType == Common_1["default"].airspaceType.polygon) {
        var ai = airspaceInfo;
        if (Array.isArray(ai.points)) {
            var polygonPoints = new Array();
            var defaultPointName = 'A';
            for (var _b = 0, _c = ai.points; _b < _c.length; _b++) {
                var obj = _c[_b];
                var addr = obj.addr;
                if (!addr) {
                    addr = defaultPointName;
                    defaultPointName = String.fromCharCode(defaultPointName.charCodeAt(0) + 1);
                }
                polygonPoints.push({ addr: addr, lat: Utils_1.latLngDecimalToDegrees(obj.lat), lng: Utils_1.latLngDecimalToDegrees(obj.lng) });
            }
            return {
                airspaceType: airspaceType,
                airspaceId: ai.airspace_id,
                name: ai.airspace_name,
                note: ai.note,
                height: ai.altitude + '',
                heightStandard: Common_1["default"].heightStandardsById.get(ai.unit),
                polygonPoints: polygonPoints
            };
        }
    }
    return null;
}
exports.convertAirspaceInfoServerToLocal = convertAirspaceInfoServerToLocal;
function convertAirspaceInfoLocalToServer(airspace) {
    if (airspace.airspaceType == Common_1["default"].airspaceType.circle) {
        var ai = airspace;
        var circle = {
            airspace_name: ai.name,
            airspace_id: ai.airspaceId,
            airspace_type: Common_1["default"].airspaceType.circle,
            note: Utils_1.isSafeString(ai.note) ? ai.note : null,
            radius_of_flying: parseInt(ai.radius + ''),
            center_point_of_flying: {
                lng: Utils_1.latLngDegreesToDecimal(ai.lng),
                lat: Utils_1.latLngDegreesToDecimal(ai.lat)
            },
            center_loc: ai.addr,
            altitude: parseInt(ai.height),
            unit: Common_1["default"].heightStandards.get(ai.heightStandard)
        };
        return circle;
    }
    else if (airspace.airspaceType == Common_1["default"].airspaceType.line) {
        var ai = airspace;
        var line = {
            airspace_name: ai.name,
            airspace_id: ai.airspaceId,
            airspace_type: Common_1["default"].airspaceType.line,
            note: ai.note,
            start_loc: ai.dep.addr,
            start_point: {
                lng: Utils_1.latLngDegreesToDecimal(ai.dep.lng),
                lat: Utils_1.latLngDegreesToDecimal(ai.dep.lat),
                altitude: parseInt(ai.dep.height),
                unit: Common_1["default"].heightStandards.get(ai.dep.heightStandard)
            },
            end_loc: ai.arrive.addr,
            end_point: {
                lng: Utils_1.latLngDegreesToDecimal(ai.arrive.lng),
                lat: Utils_1.latLngDegreesToDecimal(ai.arrive.lat)
            }
        };
        if (ai.airlineWidth) {
            line['airline_width'] = ai.airlineWidth;
        }
        if (Array.isArray(ai.passPoints) && ai.passPoints.length > 0) {
            var passing_points = [];
            for (var _i = 0, _a = ai.passPoints; _i < _a.length; _i++) {
                var obj = _a[_i];
                var retObj = void 0;
                if (obj.pointType == Common_1["default"].pointTypes.point && Utils_1.hasPoint(obj)) {
                    var pp = obj;
                    retObj = {
                        point_type: Common_1["default"].pointTypes.point,
                        point_name: pp.addr,
                        lat: Utils_1.latLngDegreesToDecimal(pp.lat),
                        lng: Utils_1.latLngDegreesToDecimal(pp.lng)
                    };
                }
                else if (obj.pointType == Common_1["default"].pointTypes.nav) {
                    var pp = obj;
                    retObj = {
                        point_type: Common_1["default"].pointTypes.nav,
                        point_name: pp.pointName,
                        point_id: pp.pointId,
                        point_code: pp.pointCode,
                        lat: Utils_1.latLngDegreesToDecimal(pp.lat),
                        lng: Utils_1.latLngDegreesToDecimal(pp.lng)
                    };
                }
                else {
                    var pp = obj;
                    retObj = {
                        point_type: Common_1["default"].pointTypes.line,
                        airway: pp.airRouteId,
                        air_route_code: pp.airlineCode,
                        points: pp.airlines
                    };
                }
                if (Utils_1.isSafeString(obj.height) && Utils_1.isSafeString(obj.heightStandard)) {
                    retObj.altitude = parseInt(obj.height);
                    // @ts-ignore
                    retObj.unit = Common_1["default"].heightStandards.get(obj.heightStandard);
                }
                passing_points.push(retObj);
            }
            line.passing_points = passing_points;
        }
        else {
            line.passing_points = [];
        }
        return line;
    }
    else {
        var ai = airspace;
        var points = [];
        for (var _b = 0, _c = ai.polygonPoints; _b < _c.length; _b++) {
            var obj = _c[_b];
            points.push({ addr: obj.addr, lat: Utils_1.latLngDegreesToDecimal(obj.lat), lng: Utils_1.latLngDegreesToDecimal(obj.lng) });
        }
        var polygon = {
            airspace_name: ai.name,
            airspace_id: ai.airspaceId,
            airspace_type: Common_1["default"].airspaceType.polygon,
            note: ai.note,
            altitude: parseInt(ai.height),
            unit: Common_1["default"].heightStandards.get(ai.heightStandard),
            points: points
        };
        return polygon;
    }
}
exports.convertAirspaceInfoLocalToServer = convertAirspaceInfoLocalToServer;
function getCircleRegions(circle) {
    var lat, lng;
    if (circle.coordinate.latitude) {
        var coord = circle.coordinate;
        lat = coord.latitude;
        lng = coord.longitude;
    }
    else {
        var coord = circle.coordinate;
        lat = coord.lat;
        lng = coord.lng;
    }
    var latlon = new LatLon(lat, lng);
    var d1 = latlon.destinationPoint(circle.radius, 0);
    var d2 = latlon.destinationPoint(circle.radius, 90);
    var d3 = latlon.destinationPoint(circle.radius, 180);
    var d4 = latlon.destinationPoint(circle.radius, 270);
    return [{ lat: d1.lat, lng: d1.lon }, { lat: d2.lat, lng: d2.lon }, { lat: d3.lat, lng: d3.lon }, { lat: d4.lat, lng: d4.lon }];
}
function getDefaultStyle() {
    var imageName = 'BA_oval';
    var lineWidth = Common_1["default"].amapLineWidth;
    var strokeColor = Common_1["default"].amapStrokeColor;
    var fillColor = Common_1["default"].amapFillColor;
    return { imageName: imageName, lineWidth: lineWidth, strokeColor: strokeColor, fillColor: fillColor };
}
function getCirclesAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex) {
    var circles = [];
    var markers = [];
    if (!Array.isArray(airspaceInfos)) {
        return { circles: circles, markers: markers };
    }
    var _a = getDefaultStyle(), imageName = _a.imageName, lineWidth = _a.lineWidth, strokeColor = _a.strokeColor, fillColor = _a.fillColor;
    //通过该方法获取样式
    var circleStyle = setStyle('circle');
    if (circleStyle) {
        lineWidth = circleStyle.lineWidth;
        strokeColor = circleStyle.strokeColor;
        fillColor = circleStyle.fillColor;
        imageName = circleStyle.imageName;
    }
    for (var i = 0; i < airspaceInfos.length; i++) {
        var tmpCircle = airspaceInfos[i];
        var airspaceTypeFix = void 0, radiusFix = void 0;
        if (tmpCircle.airspaceType) {
            airspaceTypeFix = 'airspaceType';
            radiusFix = 'radius';
        }
        else {
            airspaceTypeFix = 'airspace_type';
            radiusFix = 'radius_of_flying';
        }
        if (tmpCircle[airspaceTypeFix] == Common_1["default"].airspaceType.circle && currentAirspaceIndex != i) {
            var coordinate = { latitude: 0, longitude: 0 };
            if (tmpCircle.center_point_of_flying) {
                var ai = tmpCircle;
                coordinate.latitude = ai.center_point_of_flying.lat;
                coordinate.longitude = ai.center_point_of_flying.lng;
            }
            else {
                var ai = tmpCircle;
                coordinate.latitude = Utils_1.latLngDegreesToDecimal(ai.lat);
                coordinate.longitude = Utils_1.latLngDegreesToDecimal(ai.lng);
            }
            var radius = tmpCircle[radiusFix];
            if (radius) {
                var circle = { lineWidth: lineWidth, strokeColor: strokeColor, fillColor: fillColor, radius: radius, coordinate: coordinate };
                circles.push(circle);
            }
            else {
                // 这里的经纬度必定是数值, 所以最后一个参数是 2
                markers.push(addOvalPointConfig(coordinate.latitude, coordinate.longitude, imageName, 2));
            }
        }
    }
    return { circles: circles, markers: markers };
}
function getCircleAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    return reselect_1.createSelector(airspaceInfos, function () { return setStyle; }, currentAirspaceIndex, getCirclesAndMarkers);
}
function getLatLng(latlng, dataType) {
    if (dataType == 1) { // 驼峰模式，新建计划的时候的格式
        return Utils_1.latLngDegreesToDecimal(latlng);
    }
    else {
        return latlng;
    }
}
function drawLineConfig(lat, lng, dataType) {
    return {
        latitude: getLatLng(lat, dataType),
        longitude: getLatLng(lng, dataType)
    };
}
function addOvalPointConfig(lat, lng, imageName, dataType) {
    return {
        coordinate: {
            latitude: getLatLng(lat, dataType),
            longitude: getLatLng(lng, dataType)
        },
        imageName: imageName
    };
}
function pointCompare(point1, point2) {
    if (!point1 || !point2) {
        return false;
    }
    var pointId1 = point1.point_id;
    var pointId2 = point2.point_id;
    if (pointId1 == pointId2) {
        return true;
    }
    var _a = getFixedLatLng(point1), point1Lat = _a[0], point1lng = _a[1];
    var _b = getFixedLatLng(point2), point2lat = _b[0], point2lng = _b[1];
    if (myRound(point1Lat) == myRound(point2lat)
        && myRound(point1lng) == myRound(point2lng)) {
        return true;
    }
    else {
        return false;
    }
}
function getCrossPoint(points1, points2) {
    for (var _i = 0, points1_1 = points1; _i < points1_1.length; _i++) {
        var point1 = points1_1[_i];
        for (var _a = 0, points2_1 = points2; _a < points2_1.length; _a++) {
            var point2 = points2_1[_a];
            if (pointCompare(point1, point2))
                return point1;
        }
    }
    return undefined;
}
function getAirwayPoints(airway, pointBefore, pointAfter) {
    var found = 0;
    var points = [];
    var pointTypeFix, pointsFix, airRoutePoint;
    if ('points' in airway) {
        pointTypeFix = 'point_type';
        pointsFix = 'points';
        airRoutePoint = airway['points'];
    }
    else {
        pointTypeFix = 'pointType';
        pointsFix = 'airlines';
        airRoutePoint = airway['airlines'];
    }
    var crossPointBefore, crossPointAfter;
    // 如果前后是其他航线，那么找到交叉点作为前后的点
    if (pointBefore[pointTypeFix] == Common_1["default"].pointTypes.line) {
        crossPointBefore = getCrossPoint(airRoutePoint, pointBefore[pointsFix]);
    }
    if (pointAfter[pointTypeFix] == Common_1["default"].pointTypes.line) {
        crossPointAfter = getCrossPoint(airRoutePoint, pointAfter[pointsFix]);
    }
    for (var _i = 0, airRoutePoint_1 = airRoutePoint; _i < airRoutePoint_1.length; _i++) {
        var point = airRoutePoint_1[_i];
        if (pointCompare(crossPointBefore, point) || pointCompare(crossPointAfter, point)) {
            found++;
            points.push(Object.assign({}, point));
            continue;
        }
        if (found == 1) {
            points.push(Object.assign({}, point));
        }
    }
    if (!(points.length > 0 && found == 2)) {
        // 如果两个点不全在航线上面，那么画全部航线
        points = airRoutePoint;
    }
    return points;
}
function getLinesRouter(lineProps, lineAndMarkerStyle) {
    var coordinates = new Array();
    var markers = new Array();
    var lines = [];
    var _a = getDefaultStyle(), imageName = _a.imageName, lineWidth = _a.lineWidth, strokeColor = _a.strokeColor;
    if (lineAndMarkerStyle) {
        imageName = lineAndMarkerStyle.imageName;
        lineWidth = lineAndMarkerStyle.lineWidth;
        strokeColor = lineAndMarkerStyle.strokeColor;
    }
    var startPoint, passPoints, endPoint, pointTypeFix, dataType, airlineWidth;
    if (lineProps.start_point) {
        var ll = lineProps;
        dataType = 2; // 下划线模式
        startPoint = ll['start_point'];
        passPoints = ll['passing_points'];
        endPoint = ll['end_point'];
        pointTypeFix = 'point_type';
        airlineWidth = parseInt(ll['airline_width'] + '', 10);
    }
    else {
        var ll = lineProps;
        dataType = 1; // 驼峰模式
        startPoint = ll['dep'];
        passPoints = ll['passPoints'];
        endPoint = ll['arrive'];
        pointTypeFix = 'pointType';
        airlineWidth = parseInt(ll['airlineWidth'] + '', 10);
    }
    if (startPoint) {
        coordinates.push(drawLineConfig(startPoint.lat, startPoint.lng, dataType));
        markers.push(addOvalPointConfig(startPoint.lat, startPoint.lng, imageName, dataType));
    }
    if (Array.isArray(passPoints)) {
        for (var i = 0; i < passPoints.length; i++) {
            var obj = passPoints[i];
            if (!Utils_1.isObject(obj)) { // 所有的 points/airway 都必须是 obj
                continue;
            }
            var pointType = obj[pointTypeFix];
            if (pointType == Common_1["default"].pointTypes.point
                || pointType == Common_1["default"].pointTypes.nav) {
                var pp = obj;
                coordinates.push(drawLineConfig(pp.lat, pp.lng, dataType));
                markers.push(addOvalPointConfig(pp.lat, pp.lng, imageName, dataType));
            }
            else {
                // 遇到一个航线，不需要和前前面的点连起来
                var pp = obj;
                if (coordinates.length > 1) {
                    lines.push({ lineWidth: lineWidth, strokeColor: strokeColor, coordinates: coordinates });
                }
                coordinates = [];
                var pointBefore = i == 0 ? startPoint : passPoints[i - 1];
                var pointAfter = i == passPoints.length - 1 ? (endPoint ? endPoint : passPoints[passPoints.length - 1]) : passPoints[i + 1];
                lines.push({ lineWidth: lineWidth, strokeColor: strokeColor, coordinates: getAirwayPoints(pp, pointBefore, pointAfter) });
            }
        }
    }
    if (endPoint) {
        coordinates.push(drawLineConfig(endPoint.lat, endPoint.lng, dataType));
        markers.push(addOvalPointConfig(endPoint.lat, endPoint.lng, imageName, dataType));
    }
    if (coordinates.length > 1) {
        lines.push({ lineWidth: lineWidth, strokeColor: strokeColor, coordinates: coordinates });
    }
    if (airlineWidth > 0) {
        // 有宽度的空域，需要线周围多画宽度的多边形
        var polygons = processAirlineWidth(lines, airlineWidth);
        return { lines: lines, markers: markers, polygons: polygons };
    }
    else {
        return { lines: lines, markers: markers, polygons: [] };
    }
}
function getFixedLatLng(point) {
    var pp = point;
    var lat = pp.latitude ? pp.latitude : pp.lat;
    var lng = pp.longitude ? pp.longitude : pp.lng;
    // 复制计划的数据，有的点是度数模式如 38°35′17″
    if (Utils_1.isSafeString(lat)) {
        lat = Utils_1.latLngDegreesToDecimal(lat);
        lng = Utils_1.latLngDegreesToDecimal(lng);
    }
    return [lat, lng];
}
function processAirlineWidth(lines, airlineWidth) {
    var polygons = [];
    var _a = getDefaultStyle(), strokeColor = _a.strokeColor, fillColor = _a.fillColor;
    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
        var line = lines_1[_i];
        var points = line.coordinates;
        for (var i = 0; i < points.length - 1; i++) {
            var _b = getFixedLatLng(points[i]), lat1 = _b[0], lng1 = _b[1];
            var _c = getFixedLatLng(points[i + 1]), lat2 = _c[0], lng2 = _c[1];
            var point1 = new LatLon(lat1, lng1);
            var point2 = new LatLon(lat2, lng2);
            var coordinates = getCirclePoints(point1, point2, airlineWidth);
            polygons.push({ lineWidth: 1, strokeColor: strokeColor, fillColor: fillColor, coordinates: coordinates });
        }
    }
    return polygons;
}
function getCirclePoints(point1, point2, width) {
    var percision = 10; // 半圆处理为多边形的时候，半圆上取几个点
    var step = 180 / percision;
    var bearing = (360 + point1.bearingTo(point2) - 90) % 360; // 取正值
    var points = [];
    for (var diff = 0; diff <= 180; diff += step) {
        var point = point2.destinationPoint(width, bearing + diff);
        points.push({ lat: point.lat, lng: point.lon });
    }
    for (var diff = 180; diff <= 360; diff += step) {
        var point = point1.destinationPoint(width, bearing + diff);
        points.push({ lat: point.lat, lng: point.lon });
    }
    return points;
}
function myRound(num, digits) {
    if (digits == null)
        digits = 6; // 比较的精度，经纬度会被经过度分秒方式到浮点方式的转化
    return Math.round(num * Math.pow(10, digits)) / Math.pow(10, digits);
}
function getLinesPolygonsAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex) {
    var retLines = [];
    var retMarkers = [];
    var retPolygons = [];
    if (!Array.isArray(airspaceInfos)) {
        return { lines: retLines, markers: retMarkers, polygons: retPolygons };
    }
    var lineStyle = setStyle('line');
    for (var i = 0; i < airspaceInfos.length; i++) {
        var tmpLine = airspaceInfos[i];
        var airspaceTypeFix = void 0;
        if (tmpLine.airspaceType)
            airspaceTypeFix = 'airspaceType';
        else
            airspaceTypeFix = 'airspace_type';
        if (tmpLine[airspaceTypeFix] == Common_1["default"].airspaceType.line && currentAirspaceIndex != i) {
            var lineProps = tmpLine;
            var _a = getLinesRouter(lineProps, lineStyle), lines = _a.lines, markers = _a.markers, polygons = _a.polygons;
            retMarkers.push.apply(retMarkers, markers);
            retLines.push.apply(retLines, lines);
            retPolygons.push.apply(retPolygons, polygons);
        }
    }
    return { lines: retLines, markers: retMarkers, polygons: retPolygons };
}
function getLinePolygonsAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    return reselect_1.createSelector(airspaceInfos, function () { return setStyle; }, currentAirspaceIndex, getLinesPolygonsAndMarkers);
}
function getPolygon(polygonProps, polygonAndMarkerStyle) {
    var coordinates = new Array();
    var markers = new Array();
    var _a = getDefaultStyle(), imageName = _a.imageName, lineWidth = _a.lineWidth, strokeColor = _a.strokeColor, fillColor = _a.fillColor;
    if (polygonAndMarkerStyle) {
        imageName = polygonAndMarkerStyle.imageName;
        lineWidth = polygonAndMarkerStyle.lineWidth;
        strokeColor = polygonAndMarkerStyle.strokeColor;
        fillColor = polygonAndMarkerStyle.fillColor;
    }
    var pointsFix, dataType;
    if (polygonProps.points) {
        pointsFix = 'points';
        dataType = 2;
    }
    else {
        pointsFix = 'polygonPoints';
        dataType = 1; // 驼峰模式
    }
    if (Array.isArray(polygonProps[pointsFix])) {
        for (var _i = 0, _b = polygonProps[pointsFix]; _i < _b.length; _i++) {
            var obj = _b[_i];
            if (!obj) {
                continue;
            }
            coordinates.push(drawLineConfig(obj.lat, obj.lng, dataType));
            markers.push(addOvalPointConfig(obj.lat, obj.lng, imageName, dataType));
        }
    }
    var polygon = { lineWidth: lineWidth, strokeColor: strokeColor, fillColor: fillColor, coordinates: coordinates };
    return { markers: markers, polygon: polygon };
}
function getPolygonsAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex) {
    var markers = [];
    var polygons = [];
    if (!Array.isArray(airspaceInfos)) {
        return { markers: markers, polygons: polygons };
    }
    var polygonAndMarkerStyle = setStyle('polygon');
    for (var i = 0; i < airspaceInfos.length; i++) {
        var polygon = airspaceInfos[i];
        var airspaceTypeFix = void 0;
        if (polygon.airspaceType)
            airspaceTypeFix = 'airspaceType';
        else
            airspaceTypeFix = 'airspace_type';
        if (polygon[airspaceTypeFix] == Common_1["default"].airspaceType.polygon && currentAirspaceIndex != i) {
            var retObj = getPolygon(polygon, polygonAndMarkerStyle);
            markers.push.apply(markers, retObj.markers);
            polygons.push(retObj.polygon);
        }
    }
    return { markers: markers, polygons: polygons };
}
function getPolygonAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    return reselect_1.createSelector(airspaceInfos, function () { return setStyle; }, currentAirspaceIndex, getPolygonsAndMarkers);
}
function getMarkers(circlesAndMarkers, polygonAndMarkers, lineAndMarkers) {
    var markers = [];
    if (circlesAndMarkers) {
        markers = circlesAndMarkers.markers.slice();
    }
    if (polygonAndMarkers) {
        markers = markers.concat(polygonAndMarkers.markers);
    }
    if (lineAndMarkers) {
        markers = markers.concat(lineAndMarkers.markers);
    }
    return markers;
}
function getMarkerSelector(circlesAndMarkers, polygonAndMarkers, lineAndMarkers) {
    return reselect_1.createSelector(circlesAndMarkers, polygonAndMarkers, lineAndMarkers, getMarkers);
}
function getRegionPoints(circles, lineAndMarkers, polygonAndMarkers) {
    var regionPoints = new Array();
    for (var i = 0; i < circles.length; i++) {
        regionPoints.push.apply(regionPoints, getCircleRegions(circles[i]));
    }
    var lines = lineAndMarkers.lines;
    for (var i = 0; i < lines.length; i++) {
        regionPoints.push.apply(regionPoints, lines[i].coordinates);
    }
    var polygons = polygonAndMarkers.polygons;
    for (var i = 0; i < polygons.length; i++) {
        regionPoints.push.apply(regionPoints, polygons[i].coordinates);
    }
    return regionPoints;
}
function getRegionPointsSelector(circles, lineAndMarkers, polygonAndMarkers) {
    return reselect_1.createSelector(circles, lineAndMarkers, polygonAndMarkers, getRegionPoints);
}
function getCircles(circlesAndMarkers) {
    return circlesAndMarkers.circles;
}
function getCircleSelector(circlesAndMarkers) {
    return reselect_1.createSelector(circlesAndMarkers, getCircles);
}
function getLines(lineAndMarker) {
    return lineAndMarker.lines;
}
function getLineSelector(lineAndMarker) {
    return reselect_1.createSelector(lineAndMarker, getLines);
}
function getPolygons(polygonAndMarkers, linePolygonsAndMarkers) {
    return polygonAndMarkers.polygons.concat(linePolygonsAndMarkers.polygons);
}
function getPolygonSelector(polygonAndMarkers, linePolygonsAndMarkers) {
    return reselect_1.createSelector(polygonAndMarkers, linePolygonsAndMarkers, getPolygons);
}
var setStyle = function (styles) {
    if (!styles)
        return function () { return null; };
    else
        return function (shapeName) { return styles[shapeName]; };
};
//获取selector
function getShapesSelector(airspaceInfos, style, currentAirspaceIndex) {
    currentAirspaceIndex = currentAirspaceIndex ? currentAirspaceIndex : function () { return -1; };
    var circlesAndMarkers = getCircleAndMarkerSelector(airspaceInfos, setStyle(style), currentAirspaceIndex);
    var circles = getCircleSelector(circlesAndMarkers);
    var linePolygonsAndMarkers = getLinePolygonsAndMarkerSelector(airspaceInfos, setStyle(style), currentAirspaceIndex);
    var lines = getLineSelector(linePolygonsAndMarkers);
    var polygonAndMarkers = getPolygonAndMarkerSelector(airspaceInfos, setStyle(style), currentAirspaceIndex);
    var polygons = getPolygonSelector(polygonAndMarkers, linePolygonsAndMarkers);
    var markers = getMarkerSelector(circlesAndMarkers, polygonAndMarkers, linePolygonsAndMarkers);
    var regionPoints = getRegionPointsSelector(circles, linePolygonsAndMarkers, polygonAndMarkers);
    return {
        markers: markers,
        circles: circles,
        lines: lines,
        polygons: polygons,
        regionPoints: regionPoints
    };
}
exports.getShapesSelector = getShapesSelector;
//获取数组
function getShapes(airspaceInfos, style, currentAirspaceIndex) {
    var _a = getShapesSelector(function () { return airspaceInfos; }, style, function () { return currentAirspaceIndex; }), markers = _a.markers, polygons = _a.polygons, circles = _a.circles, lines = _a.lines, regionPoints = _a.regionPoints;
    return {
        markers: markers(airspaceInfos),
        circles: circles(airspaceInfos),
        lines: lines(airspaceInfos),
        polygons: polygons(airspaceInfos),
        regionPoints: regionPoints(airspaceInfos)
    };
}
exports.getShapes = getShapes;
// 总共 5 种格式, http://git.corp.brilliantaero.com/BA/Coco/issues/99#note_6358
// 1. 全输出格式
// 2. 简化格式
// 3. 传真格式
// 4. 用户端用的简化格式
// 5. 极简格式
function getHeight(height, unit, type) {
    var shortNum;
    var num = +height; // to number
    if (num >= 100) {
        shortNum = parseInt(num / 100 + '').toString();
        if (shortNum.length < 2) {
            shortNum = '0' + shortNum;
        }
    }
    var heightStandard = Common_1["default"].heightStandardsById.get(unit);
    if (!heightStandard) {
        heightStandard = unit;
    }
    // 这里统一使用数字判断
    var standardUnit = Common_1["default"].heightStandards.get(heightStandard);
    var heightDesc;
    switch (standardUnit) {
        case 1:
            heightDesc = ['H*真', '真高*米'];
            break;
        case 2:
            heightDesc = ['H*标(含以下)', '标高*米(含以下)'];
            break;
        case 3:
            heightDesc = ['H*真(含以下)', '真高*米(含以下)'];
            break;
        default:
            heightDesc = ['H*标', '标高*米'];
    }
    if (shortNum && (type == 1 || type == 2)) {
        // H02真，H02真(含以下)
        return heightDesc[0].replace('*', shortNum);
    }
    else {
        // 真高200米，真高200米(含以下)
        return heightDesc[1].replace('*', height + '');
    }
}
function getAirspaceName(airspaceInfo) {
    if (airspaceInfo.airspace_name) {
        var ai = airspaceInfo;
        return ai.airspace_name;
    }
    else {
        var ai = airspaceInfo;
        return ai.name;
    }
}
function circleContent(airspaceInfo, type) {
    if (type === void 0) { type = 3; }
    if (type == 5)
        return getAirspaceName(airspaceInfo);
    if ('airspace_name' in airspaceInfo) {
        var lat = Utils_1.latLngDecimalToDegrees(airspaceInfo.center_point_of_flying.lat);
        var lng = Utils_1.latLngDecimalToDegrees(airspaceInfo.center_point_of_flying.lng);
        var content = [];
        var loc = "\u4EE5" + airspaceInfo.center_loc;
        if (type == 1 || type == 3)
            loc += "(E" + lng + ", N" + lat + ")";
        content.push(loc + "\u4E3A\u4E2D\u5FC3");
        content.push("\u534A\u5F84" + airspaceInfo.radius_of_flying + "\u7C73");
        content.push(getHeight(airspaceInfo.altitude, airspaceInfo.unit, type));
        if (airspaceInfo.note)
            content.push("\u5907\u6CE8\uFF1A" + airspaceInfo.note);
        return content.join('，');
    }
    else {
        var content = [];
        var loc = "\u4EE5" + airspaceInfo.addr;
        if (type == 1 || type == 3)
            loc += "(E" + airspaceInfo.lng + ", N" + airspaceInfo.lat + ")";
        content.push(loc + "\u4E3A\u4E2D\u5FC3");
        content.push("\u534A\u5F84" + airspaceInfo.radius + "\u7C73");
        content.push(getHeight(airspaceInfo.height, airspaceInfo.heightStandard, type));
        if (airspaceInfo.note)
            content.push("\u5907\u6CE8\uFF1A" + airspaceInfo.note);
        return content.join('，');
    }
}
exports.circleContent = circleContent;
function flyingCenter(item) {
    if (item === void 0) { item = {}; }
    if (item == {}) {
        return "";
    }
    var pp = item;
    return ("(E" + Utils_1.latLngDecimalToDegrees(pp.lng) +
        ', ' +
        "N" + Utils_1.latLngDecimalToDegrees(pp.lat) + ")");
}
function lineContent(airspaceInfo, type) {
    if (type === void 0) { type = 3; }
    if (type == 5)
        return getAirspaceName(airspaceInfo);
    if ('airspace_name' in airspaceInfo) {
        var content = [];
        content.push("" + airspaceInfo.start_loc);
        if (type == 1 || type == 3)
            content.push("" + flyingCenter(airspaceInfo.start_point));
        content.push(" - ");
        content.push(getHeight(airspaceInfo.start_point.altitude, airspaceInfo.start_point.unit, type));
        var passing_points = airspaceInfo.passing_points;
        if (Array.isArray(passing_points)) {
            for (var i = 0; i < passing_points.length; i++) {
                var obj = passing_points[i];
                if (obj.point_type == Common_1["default"].pointTypes.point) {
                    var pp = obj;
                    var lat = Utils_1.latLngDecimalToDegrees(pp.lat);
                    var lng = Utils_1.latLngDecimalToDegrees(pp.lng);
                    content.push(" - " + pp.point_name);
                    if (type == 1 || type == 3)
                        content.push("(E" + lng + ", N" + lat + ")");
                }
                else if (obj.point_type == Common_1["default"].pointTypes.nav) {
                    var pp = obj;
                    var lat = Utils_1.latLngDecimalToDegrees(pp.lat);
                    var lng = Utils_1.latLngDecimalToDegrees(pp.lng);
                    content.push(" - " + pp.point_code);
                    if (type == 1 || type == 3)
                        content.push("(E" + lng + ", N" + lat + ")");
                }
                else {
                    var pp = obj;
                    content.push(" - " + pp.air_route_code);
                }
                if (obj.altitude) {
                    content.push(" - " + getHeight(obj.altitude, obj.unit, type));
                }
            }
        }
        content.push(" - " + airspaceInfo.end_loc);
        if (type == 1 || type == 3)
            content.push("" + flyingCenter(airspaceInfo.end_point));
        if (Utils_1.isSafeString(airspaceInfo.airline_width)) {
            content.push("\uFF0C\u5BBD\u5EA6\uFF1A" + airspaceInfo.airline_width + "\u7C73");
        }
        if (Utils_1.isSafeString(airspaceInfo.note)) {
            content.push("\uFF0C\u5907\u6CE8\uFF1A " + airspaceInfo.note);
        }
        var result = content.join("");
        return result;
    }
    else {
        var content = [];
        content.push("" + airspaceInfo.dep.addr);
        if (type == 1 || type == 3)
            content.push("(E" + airspaceInfo.dep.lng + ", N" + airspaceInfo.dep.lat + ")");
        content.push(" - " + getHeight(airspaceInfo.dep.height, airspaceInfo.dep.heightStandard, type));
        if (Array.isArray(airspaceInfo.passPoints)) {
            var length_1 = airspaceInfo.passPoints.length;
            for (var i = 0; i < length_1; i++) {
                var obj = airspaceInfo.passPoints[i];
                if (obj.pointType == Common_1["default"].pointTypes.point) {
                    var pp = obj;
                    content.push(" - " + pp.addr);
                    if (type == 1 || type == 3)
                        content.push("(E" + pp.lng + ", N" + pp.lat + ")");
                }
                else if (obj.pointType == Common_1["default"].pointTypes.nav) {
                    var pp = obj;
                    content.push(" - " + pp.pointCode);
                    if (type == 1 || type == 3)
                        content.push("(E" + pp.lng + ", N" + pp.lat + ")");
                }
                else {
                    var pp = obj;
                    content.push(" - " + pp.airlineCode);
                }
                if (obj.height) {
                    content.push(" - " + getHeight(obj.height, obj.heightStandard, type));
                }
            }
        }
        content.push(" - " + airspaceInfo.arrive.addr);
        if (type == 1 || type == 3)
            content.push("(E" + airspaceInfo.arrive.lng + ", N" + airspaceInfo.arrive.lat + ")");
        if (airspaceInfo.airlineWidth) {
            content.push("\uFF0C\u5BBD\u5EA6\uFF1A" + airspaceInfo.airlineWidth + "\u7C73");
        }
        if (airspaceInfo.note)
            content.push("\uFF0C\u5907\u6CE8\uFF1A" + airspaceInfo.note);
        return content.join('');
    }
}
exports.lineContent = lineContent;
function polygonContent(airspaceInfo, type) {
    if (type === void 0) { type = 3; }
    if (type == 5)
        return getAirspaceName(airspaceInfo);
    if ('airspace_name' in airspaceInfo) {
        var res = [];
        var points = airspaceInfo.points;
        for (var i = 0; i < points.length; i++) {
            var c = "" + (points[i].addr ? points[i].addr : '');
            if (type == 1 || type == 3)
                c += "(E" + Utils_1.latLngDecimalToDegrees(points[i].lng) + ", N" + Utils_1.latLngDecimalToDegrees(points[i].lat) + ")";
            res.push(c);
        }
        var content = [res.join('、')];
        content.push(airspaceInfo.points.length + "\u70B9\u8FDE\u7EBF\u8303\u56F4\u5185");
        content.push("\uFF0C" + getHeight(airspaceInfo.altitude, airspaceInfo.unit, type));
        if (Utils_1.isSafeString(airspaceInfo.note)) {
            content.push("\uFF0C\u5907\u6CE8\uFF1A" + airspaceInfo.note);
        }
        return content.join('');
    }
    else {
        var content = [];
        var length_2 = airspaceInfo.polygonPoints.length;
        for (var i = 0; i < length_2; i++) {
            var obj = airspaceInfo.polygonPoints[i];
            var c = "" + (obj.addr ? obj.addr : '');
            if (type == 1 || type == 3)
                c += "(E" + obj.lng + ", N" + obj.lat + ")";
            content.push(c);
        }
        var cc = content.join('、') + (length_2 + "\u70B9\u8FDE\u7EBF\u8303\u56F4\u5185");
        cc += "\uFF0C" + getHeight(airspaceInfo.height, airspaceInfo.heightStandard, type);
        if (airspaceInfo.note)
            cc = content + "\uFF0C\u5907\u6CE8\uFF1A" + airspaceInfo.note;
        return cc;
    }
}
exports.polygonContent = polygonContent;