高德地图计算多个多边形组成整个区域的外多边形坐标数组

        // 计算多个多边形的外轮廓
        function calculateOuterBoundary(allPolygons) {
            let allPoints = [];

            // 收集所有多边形的点
            allPolygons.forEach(polygon => {
                allPoints = allPoints.concat(polygon);
            });

            // 使用凸包算法计算外轮廓
            return convexHull(allPoints);
        }

        // 凸包算法（Graham扫描法）
        function convexHull(points) {
            if (points.length < 3) return points;

            // 找到最左下角的点作为起始点
            let start = 0;
            for (let i = 1; i < points.length; i++) {
                if (points[i][1] < points[start][1] ||
                    (points[i][1] === points[start][1] && points[i][0] < points[start][0])) {
                    start = i;
                }
            }

            // 按极角排序
            const startPoint = points[start];
            const sortedPoints = points.slice();
            sortedPoints.splice(start, 1);

            sortedPoints.sort((a, b) => {
                const angleA = Math.atan2(a[1] - startPoint[1], a[0] - startPoint[0]);
                const angleB = Math.atan2(b[1] - startPoint[1], b[0] - startPoint[0]);
                if (angleA === angleB) {
                    // 如果角度相同，按距离排序
                    const distA = Math.pow(a[0] - startPoint[0], 2) + Math.pow(a[1] - startPoint[1], 2);
                    const distB = Math.pow(b[0] - startPoint[0], 2) + Math.pow(b[1] - startPoint[1], 2);
                    return distA - distB;
                }
                return angleA - angleB;
            });

            // Graham扫描
            const hull = [startPoint];

            for (let point of sortedPoints) {
                while (hull.length > 1 &&
                    crossProduct(hull[hull.length - 2], hull[hull.length - 1], point) <= 0) {
                    hull.pop();
                }
                hull.push(point);
            }

            return hull;
        }

        // 计算叉积，用于判断三点的转向
        function crossProduct(o, a, b) {
            return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
        }

 const allPolygons = [];
// 收集所有多边形坐标用于计算外轮廓
allPolygons.push(item.geometry.coordinates[0]);

// 计算整个区域的外多边形
const outerBoundary = calculateOuterBoundary(allPolygons);