amap-shapes-generator/index.js

import { createSelector } from 'reselect';
import Global from './Common';
import {
    latLngDegreesToDecimal,
    isObject,
    isUndefined,
    isString,
    isSafeString,
    hasLine,
    hasPoint
} from './Utils'
let LatLon = require('geodesy').LatLonSpherical;

function getCircleRegions(circle) {
    let latlon = new LatLon(circle.coordinate.latitude, circle.coordinate.longitude)
    let d1 = latlon.destinationPoint(circle.radius, 0)
    let d2 = latlon.destinationPoint(circle.radius, 90)
    let d3 = latlon.destinationPoint(circle.radius, 180)
    let 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 getCircles(airspaceInfos, setStyle, currentAirspaceIndex) {
    let circles = [];
    if (!Array.isArray(airspaceInfos)) {
        return circles;
    }
    //通过该方法获取样式
    let circleStyle = setStyle('circle');
    for (let i = 0; i < airspaceInfos.length; i++) {
        let tmpCircle = airspaceInfos[i]
        if (tmpCircle.airspaceType == Global.airspaceType.circle && currentAirspaceIndex != i) {
            let coordinate = {};
            coordinate.latitude = latLngDegreesToDecimal(tmpCircle.lat);
            coordinate.longitude = latLngDegreesToDecimal(tmpCircle.lng);
            let radius = tmpCircle.radius;
            let circle = {
                lineWidth: circleStyle.lineWidth ? circleStyle.lineWidth : Global.amapLineWidth,
                strokeColor: circleStyle.strokeColor ? circleStyle.strokeColor : Global.amapStrokeColor,
                fillColor: circleStyle.fillColor ? circleStyle.fillColor : Global.amapFillColor,
                radius,
                coordinate
            }
            circles.push(circle);
        }
    }

    return circles;
}

function getCircleSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    return createSelector(
        airspaceInfos,
        () => setStyle,
        currentAirspaceIndex,
        getCircles
    );
}


function drawLineConfig(lat, lng) {
    let coordinate = {};
    coordinate.latitude = latLngDegreesToDecimal(lat);
    coordinate.longitude = latLngDegreesToDecimal(lng);
    return coordinate;
}

function addOvalPointConfig(lat, lng, imageName) {
    let coordinate = {};
    coordinate.latitude = latLngDegreesToDecimal(lat);
    coordinate.longitude = latLngDegreesToDecimal(lng);

    let annotationConfig = {};
    annotationConfig.coordinate = coordinate;
    annotationConfig.imageName = imageName;

    return annotationConfig
}


function getAirwayLine(airway, pointBefore, pointAfter, lineAndMarkerStyle) {
    let found = 0
    let points = []

    for (let point of airway.points) {
        if (pointBefore.point_id == point.point_id || pointAfter.point_id == point.point_id) {
            found++
            points.push(Object.assign({}, point))
            continue
        }

        if (found == 1) {
            points.push(Object.assign({}, point))
        }
    }

    if (!(points.length > 0 && found == 2)) {
        // 如果两个点不全在航线上面，那么画全部航线
        points = airway.points
    }

    let line = {
        lineWidth: lineAndMarkerStyle.lineWidth ? lineAndMarkerStyle.lineWidth : Global.amapLineWidth,
        strokeColor: lineAndMarkerStyle.strokeColor ? lineAndMarkerStyle.strokeColor : Global.amapStrokeColor,
        coordinates: points
    }
    return { line };
}



function getLinesRouter(lineProps, lineAndMarkerStyle) {
    let coordinates = new Array();
    let markers = new Array();
    let lines = []

    if (hasLine(lineProps.dep)) {
        coordinates.push(drawLineConfig(lineProps.dep.lat, lineProps.dep.lng));
        markers.push(addOvalPointConfig(lineProps.dep.lat, lineProps.dep.lng, lineAndMarkerStyle.imageName ? lineAndMarkerStyle.imageName : 'BA_oval'));
    }

    if (Array.isArray(lineProps.passPoints)) {
        for (let i = 0; i < lineProps.passPoints.length; i++) {
            let obj = lineProps.passPoints[i]
            if (isObject(obj)) {
                continue;
            }

            if (obj.pointType == Global.pointTypes.point
                || obj.pointType == Global.pointTypes.nav) {
                coordinates.push(drawLineConfig(obj.lat, obj.lng));
                markers.push(addOvalPointConfig(obj.lat, obj.lng, lineAndMarkerStyle.imageName ? lineAndMarkerStyle.imageName : 'BA_oval'));
            } else {
                // 遇到一个航线，不需要和前前面的点连起来
                if (coordinates.length > 1) {
                    lines.push({
                        lineWidth: lineAndMarkerStyle.lineWidth ? lineAndMarkerStyle.lineWidth : Global.amapLineWidth,
                        strokeColor: lineAndMarkerStyle.strokeColor ? lineAndMarkerStyle.strokeColor : Global.amapStrokeColor,
                        coordinates: coordinates
                    })
                }

                coordinates = []

                const pointBefore = i == 0 ? lineProps.dep : lineProps.passPoints[i - 1]
                const pointAfter = i == lineProps.passPoints.length - 1 ? lineProps.arrive : lineProps.passPoints[i + 1]

                lines.push(getAirwayLine(obj, pointBefore, pointAfter, lineAndMarkerStyle))
            }
        }
    }

    if (hasLine(lineProps.arrive)) {
        coordinates.push(drawLineConfig(lineProps.arrive.lat, lineProps.arrive.lng));
        markers.push(addOvalPointConfig(lineProps.arrive.lat, lineProps.arrive.lng, lineAndMarkerStyle.imageName ? lineAndMarkerStyle.imageName : 'BA_oval'));
    }

    if (coordinates.length > 1) {
        lines.push({
            lineWidth: lineAndMarkerStyle.lineWidth ? lineAndMarkerStyle.lineWidth : Global.amapLineWidth,
            strokeColor: lineAndMarkerStyle.strokeColor ? lineAndMarkerStyle.strokeColor : Global.amapStrokeColor,
            coordinates: coordinates
        });
    }

    return { lines, markers };

}

function getLinesAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex) {
    let retLines = [];
    let retMarkers = [];
    if (!Array.isArray(airspaceInfos)) {
        return { lines: retLines, markers: retMarkers };
    }
    let lineStyle = setStyle('line');
    for (let i = 0; i < airspaceInfos.length; i++) {
        let tmpLine = airspaceInfos[i]
        if (tmpLine.airspaceType == Global.airspaceType.line && currentAirspaceIndex != i) {
            let { lines, markers } = getLinesRouter(tmpLine, lineStyle);
            retMarkers.push(...markers);
            retLines.push(...lines);
        }
    }

    return { lines: retLines, markers: retMarkers };
}


function getLineAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    return createSelector(
        airspaceInfos,
        () => setStyle,
        currentAirspaceIndex,
        getLinesAndMarkers
    );
}

function getPolygon(polygonProps, polygonAndMarkerStyle) {
    let coordinates = new Array();
    let markers = new Array();

    if (Array.isArray(polygonProps.polygonPoints)) {
        for (let obj of polygonProps.polygonPoints) {
            if (!hasPoint(obj)) {
                continue;
            }
            coordinates.push(drawLineConfig(obj.lat, obj.lng));
            markers.push(addOvalPointConfig(obj.lat, obj.lng, polygonAndMarkerStyle.imageName ? polygonAndMarkerStyle.imageName : 'BA_oval'));
        }
    }

    if (coordinates.length > 0) {
        let polygon = {
            lineWidth: polygonAndMarkerStyle.lineWidth ? polygonAndMarkerStyle.lineWidth : Global.amapLineWidth,
            strokeColor: polygonAndMarkerStyle.strokeColor ? polygonAndMarkerStyle.strokeColor : Global.amapStrokeColor,
            fillColor: polygonAndMarkerStyle.fillColor ? polygonAndMarkerStyle.fillColor : Global.amapFillColor,
            coordinates: coordinates
        };

        return { markers, polygon };
    }
}


function getPolygonsAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex) {
    let markers = [];
    let polygons = [];
    if (!Array.isArray(airspaceInfos)) {
        return { markers, polygons };
    }
    let polygonAndMarkerStyle = setStyle('polygon');
    for (let i = 0; i < airspaceInfos.length; i++) {
        let polygon = airspaceInfos[i]
        if (polygon.airspaceType == Global.airspaceType.polygon && currentAirspaceIndex != i) {
            let retObj = getPolygon(polygon, polygonAndMarkerStyle);
            markers.push(...retObj.markers);
            polygons.push(retObj.polygon);
        }
    }
    return { markers, polygons };

}

function getPolygonAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    return createSelector(
        airspaceInfos,
        () => setStyle,
        currentAirspaceIndex,
        getPolygonsAndMarkers
    );
}

function getMarkers(polygonAndMarkers, lineAndMarkers) {
    let markers = [];
    if (polygonAndMarkers) {
        markers = [...polygonAndMarkers.markers]
    }
    if (lineAndMarkers) {
        markers = [...markers, ...lineAndMarkers.markers]
    }
    return markers
}

function getMarkerSelector(polygonAndMarkers, lineAndMarkers) {
    return createSelector(
        polygonAndMarkers,
        lineAndMarkers,
        getMarkers
    )
}

function getRegionPoints(circles, lineAndMarkers, polygonAndMarkers) {
    let regionPoints = new Array();
    
    for (let i = 0; i < circles.length; i++) {
        regionPoints.push(getCircleRegions(circles[i]));
    }
    
    if(Array.isArray(lineAndMarkers.lines)) {
        let lines = lineAndMarkers.lines;
        for (let i = 0; i < lines.length; i++) {
            regionPoints.push(lines[i].coordinates);
        }
    }
    
    if(Array.isArray(lineAndMarkers.polygons)) {
        let polygons = getPolygonsAndMarkers.polygons;
        for (let i = 0; i < polygons.length; i++) {
            regionPoints.push(polygons.coordinates);
        }
    }
    
    return regionPoints;
}

function getRegionPointsSelector(circles, lineAndMarkers, polygonAndMarkers) {
    return createSelector(
        circles,
        lineAndMarkers,
        polygonAndMarkers,
        getRegionPoints
    );
}

function getLines(lineAndMarker) {
    return lineAndMarker.lines;
}

function getLineSelector(lineAndMarker) {
    return createSelector(
        lineAndMarker,
        getLines
    );
}

function getPolygons(polygonAndMarkers) {
    return polygonAndMarkers.polygons;
}

function getPolygonSelector(polygonAndMarkers) {
    return createSelector(
        polygonAndMarkers,
        getPolygons
    );
}

//获取selector
export function getShapesSelector(airspaceInfos, setStyle, currentAirspaceIndex) {
    currentAirspaceIndex = currentAirspaceIndex ? currentAirspaceIndex : () => -1;
    let circles = getCircleSelector(airspaceInfos, setStyle, currentAirspaceIndex);
    let lineAndMarkers = getLineAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex);
    let lines = getLineSelector(lineAndMarkers);
    let polygonAndMarkers = getPolygonAndMarkerSelector(airspaceInfos, setStyle, currentAirspaceIndex);
    let polygons = getPolygonSelector(polygonAndMarkers);
    let markers = getMarkerSelector(polygonAndMarkers, lineAndMarkers);
    let regionPoints = getRegionPointsSelector(circles, lineAndMarkers, polygonAndMarkers);
    return {
        markers,
        circles,
        lines,
        polygons,
        regionPoints
    }
}
//获取数组
export function getShapes(airspaceInfos, setStyle, currentAirspaceIndex) {
    currentAirspaceIndex = currentAirspaceIndex ? currentAirspaceIndex : () => -1;
    let circles = getCircles(airspaceInfos, setStyle, currentAirspaceIndex);
    let lineAndMarkers = getLinesAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex);
    let lines = getLines(lineAndMarkers);
    let polygonAndMarkers = getPolygonsAndMarkers(airspaceInfos, setStyle, currentAirspaceIndex);
    let polygons = getPolygons(getPolygonsAndMarkers);
    let markers = getMarkers(polygonAndMarkers, lineAndMarkers);
    let regionPoints = getRegionPoints(circles, lineAndMarkers, polygonAndMarkers);
    return {
        markers,
        circles,
        lines,
        polygons,
        regionPoints
    }
}