给定面坐标，求可以切割成250*250平方米正方形的坐标

要将给定的多边形区域划分为若干个250米 x 250米的正方形，并获取每个正方形的坐标，可以按照以下步骤进行：
1、解析输入的坐标：将输入的字符串转换为坐标数组。

2、确定多边形的边界：计算多边形的最小和最大经纬度。
3、划分网格：根据多边形的边界和250米的步长，生成网格。
4、过滤网格：确保生成的网格完全在多边形内部。
以下是实现这些步骤的Java代码示例：

import java.util.ArrayList;
import java.util.List;

public class GridDivider {

    public static void main(String[] args) {
        String x = "29.8741287543877,29.8741992517513,29.8720583316997,29.8702313984507,29.8702309850485,29.8691132095773," +
                "29.8667335212061,29.8653947022791,29.8619715329274,29.8599611359497,29.8580258837353,29.8540065238787," +
                "29.8513998045102,29.8480403499797,29.8463978535294,29.8422197387928,29.841696674943,29.8435219528194," +
                "29.843908981009,29.843865116073,29.8449680390308,29.8532696389656,29.863961132215,29.8741287543877,29.8742017004173,";//经度
        String y = "121.598329353396,121.60277369534,121.610730395799,121.618869045909,121.619726335635,121.620842091365,121.619986718689," +
                "121.619301946826,121.618190121492,121.617248653692,121.617078294179,121.616908438869,121.616223523704,121.613739757034," +
                "121.612883356644,121.611512669197,121.611255707861,121.601762594103,121.598087754024,121.595609749212,121.590910578331," +
                "121.592961004857,121.595604298845,121.598329353396,121.598243826404";//纬度

        List<Double> xCoords = parseCoordinates(x);
        List<Double> yCoords = parseCoordinates(y);

        double minX = xCoords.stream().min(Double::compare).get();
        double maxX = xCoords.stream().max(Double::compare).get();
        double minY = yCoords.stream().min(Double::compare).get();
        double maxY = yCoords.stream().max(Double::compare).get();

        double gridSize = 250.0 / 111320.0; // 250米转换为经纬度差值（近似）

        List<GridSquare> gridSquares = generateGrid(minX, maxX, minY, maxY, gridSize);

        // 过滤出在多边形内的网格
        List<GridSquare> filteredGridSquares = filterGridSquares(gridSquares, xCoords, yCoords);

        // 打印结果
        for (GridSquare square : filteredGridSquares) {
            System.out.println(square);
        }
    }

    private static List<Double> parseCoordinates(String coords) {
        return List.of(coords.split(",")).stream()
                .map(Double::parseDouble)
                .collect(Collectors.toList());
    }

    private static List<GridSquare> generateGrid(double minX, double maxX, double minY, double maxY, double gridSize) {
        List<GridSquare> gridSquares = new ArrayList<>();

        for (double x = minX; x < maxX; x += gridSize) {
            for (double y = minY; y < maxY; y += gridSize) {
                gridSquares.add(new GridSquare(x, y, x + gridSize, y + gridSize));
            }
        }

        return gridSquares;
    }

    private static List<GridSquare> filterGridSquares(List<GridSquare> gridSquares, List<Double> xCoords, List<Double> yCoords) {
        List<GridSquare> filteredGridSquares = new ArrayList<>();

        for (GridSquare square : gridSquares) {
            if (isInsidePolygon(square, xCoords, yCoords)) {
                filteredGridSquares.add(square);
            }
        }

        return filteredGridSquares;
    }

    private static boolean isInsidePolygon(GridSquare square, List<Double> xCoords, List<Double> yCoords) {
        int n = xCoords.size();
        boolean inside = false;

        for (int i = 0, j = n - 1; i < n; j = i++) {
            double xi = xCoords.get(i), yi = yCoords.get(i);
            double xj = xCoords.get(j), yj = yCoords.get(j);

            if (((yi > square.getMinY()) != (yj > square.getMinY())) &&
                (square.getMinX() < (xj - xi) * (square.getMinY() - yi) / (yj - yi) + xi)) {
                inside = !inside;
            }
        }

        return inside;
    }

    static class GridSquare {
        private final double minX;
        private final double minY;
        private final double maxX;
        private final double maxY;

        public GridSquare(double minX, double minY, double maxX, double maxY) {
            this.minX = minX;
            this.minY = minY;
            this.maxX = maxX;
            this.maxY = maxY;
        }

        public double getMinX() {
            return minX;
        }

        public double getMinY() {
            return minY;
        }

        public double getMaxX() {
            return maxX;
        }

        public double getMaxY() {
            return maxY;
        }

        @Override
        public String toString() {
            return "GridSquare{" +
                    "minX=" + minX +
                    ", minY=" + minY +
                    ", maxX=" + maxX +
                    ", maxY=" + maxY +
                    '}';
        }
    }
}

代码说明：
1、解析坐标：parseCoordinates 方法将输入的字符串转换为 List<Double>。
2、确定多边形的边界：使用 stream API 计算多边形的最小和最大经纬度。

3、生成网格：
     generateGrid 方法根据多边形的边界和250米的步长生成网格。注意250米转换为经纬度差值的近似值为 250.0 / 111320.0。
4、过滤网格：
    filterGridSquares 方法过滤出在多边形内的网格。
    isInsidePolygon 方法