Java 在2个地理点之间生成可能的路径

我目前正在做一项大学作业，要求我能够以某种方式在地图上的两点之间生成可能的路线

我的路线生成有问题。我基本上从2个点A和B开始，在这些点之间创建一条边，我的算法取中点，在中点的稍左侧和右侧生成2个新点，并创建新边。所以1边有3种不同的可能性

下面是问题的一个可爱的绘画插图：

在第一种情况下这很好，但是在第二次迭代中，我遇到了麻烦，因为在每个路线中都有2条边。我不确定如何迭代该过程以生成新路线。我想重复这个过程来创建14条边的路由，我认为这会产生2744条不同的可能路由

下面是我添加第一个“基本边”的代码，接下来是迭代部分，我不确定如何开始：

List<RouteGraph> routes = new ArrayList<>();

    // Add Base Edge between A and B

    MarkerNode nodeA = new MarkerNode(markers.get(0).getLat(), markers.get(0).getLng(), markers.get(0).getElevation());
    MarkerNode nodeB = new MarkerNode(markers.get(1).getLat(), markers.get(1).getLng(), markers.get(1).getElevation());

    RouteGraph baseRoute = new RouteGraph();

    baseRoute.addEdge(nodeA, nodeB);

    routes.add(baseRoute);

List routes=new ArrayList（）；
//在A和B之间添加基础边
MarkerNode nodeA=newmarkernode（markers.get（0）.getLat（），markers.get（0）.getLng（），markers.get（0）.getElevation（））；
MarkerNode nodeB=newmarkernode（markers.get（1）.getLat（），markers.get（1）.getLng（），markers.get（1）.getElevation（））；
RouteGraph baseRoute=新RouteGraph（）；
基本路由添加（节点A、节点B）；
routes.add（baseRoute）；

一种解决方案是递归收缩边，如下代码所示：

import java.util.ArrayList;
import java.util.List;
import javafx.geometry.Point2D;
import javafx.scene.shape.Line;

public class DrawGraph {

    private static Point2D start = new Point2D(150,450);
    private static Point2D end = new Point2D(450,150);

    public static void main(String[] args) {
        List<Line> edges = makeEdges(4, start, end);
    }

    /**
     * @param start, end  represent base line
     * @param numberOfLevels  number of levels to build
     * @return a list of all edges.
     */
    private static List<Line> makeEdges(int numberOfLevels, Point2D start, Point2D end){
        List<Line> edges = new ArrayList<>();
        makeEdge(numberOfLevels, start, end, edges);
        return edges;
    }

    //recursive construct edges
    private static void makeEdge( int levels, Point2D start, Point2D end, List<Line> edges) {

        if(levels < 0) return ;
        //add edge to list
        edges.add(new Line(start.getX(), start.getY(), end.getX(), end.getY()));
        //make 2 new points 
        Point2D[] newPoints  = makeNewPoints(start, end);
        //recursive make 4 new lines
        makeEdge(levels - 1, start, newPoints[0],edges);
        makeEdge(levels - 1, newPoints[0], end, edges);
        makeEdge(levels - 1, start, newPoints[1], edges);
        makeEdge(levels - 1, newPoints[1], end, edges);
    }

    //returns 2 new points on the center line of the line represented by start, end
    //the algorithm calculating the new points can be changed as need 
    private static Point2D[] makeNewPoints(Point2D start, Point2D end){

        //edge's mid point
        Point2D midPoint = lineMidPoint(start, end);
        //the inclination angle of the edge
        double angle = lineAngle(start, end);
        //the distance of the 2 new points from the edge. change as needed
        double distance = lineLength(start, midPoint) /4 ; //set to edge length / 4
        //represents the change in x and in y from midpoint to new point
        Point2D deltaXY = newPoint(midPoint, distance, angle);
        //make and return 2 new points
        return new Point2D[]{
                new Point2D(midPoint.getX() + deltaXY.getX(), midPoint.getY() + deltaXY.getY()),
                new Point2D(midPoint.getX() - deltaXY.getX(), midPoint.getY() - deltaXY.getY())
        };
    }

    //mid point between two points
    private static Point2D lineMidPoint(Point2D p1, Point2D p2) {

        return new Point2D((p1.getX() + p2.getX()) /
                2, (p1.getY() + p2.getY()) / 2);
    }

    //angle in radians of a line represented by two points
    private static double lineAngle(Point2D start, Point2D end) {

        double deltaY =  start.getY() - end.getY() ;
        double deltaX =  end.getX()- start.getX()  ;
        return Math.atan2(deltaY, deltaX);
    }

    //length of a line represented by two points
    private static double lineLength(Point2D start, Point2D end) {

        double deltaY = end.getY() - start.getY();
        double deltaX = end.getX() - start.getX();
        return Math.sqrt(deltaY*deltaY + deltaX*deltaX);
    }

    //construct a new point at a distance from point p. angle represents the
    //angle of the line p is on.
    private static Point2D newPoint(Point2D p, double distance, double angle) {

        double deltaY = distance * Math.cos(angle);
        double deltaX = distance * Math.sin(angle);
        return  new Point2D(deltaX, deltaY) ;
    }
}

import java.util.ArrayList；
导入java.util.List；
导入javafx.geometry.Point2D；
导入javafx.scene.shape.Line；
公共类绘图机{
私有静态Point2D开始=新的Point2D（150450）；
专用静态点2D结束=新点2D（450150）；
公共静态void main（字符串[]args）{
列表边=生成边（4，开始，结束）；
}
/**
*@param start，end表示基线
*@param numberOfLevels要构建的级别数
*@返回所有边的列表。
*/
私有静态列表makeEdges（int numberOfLevels、Point2D start、Point2D end）{
列表边=新的ArrayList（）；
makeEdge（NumberOfLevel、开始、结束、边缘）；
返回边；
}
//递归构造边
私有静态void makeEdge（int级别、Point2D开始、Point2D结束、列表边）{
如果（水平<0）返回；
//将边添加到列表中
add（新行（start.getX（），start.getY（），end.getX（），end.getY（））；
//提出两个新观点
Point2D[]newPoints=makeNewPoints（开始、结束）；
//递归生成4行新行
makeEdge（级别-1，开始，新点[0]，边）；
makeEdge（级别-1，新点[0]，结束，边）；
makeEdge（级别-1，开始，新点[1]，边）；
makeEdge（级别-1，新点[1]，结束，边）；
}
//返回起点、终点表示的直线中心线上的2个新点
//计算新点的算法可以根据需要进行更改
私有静态Point2D[]生成新点（Point2D开始，Point2D结束）{
//边缘中点
点2D中点=线中点（起点、终点）；
//边缘的倾斜角度
双角度=线性角（起点、终点）；
//两个新点与边缘的距离。根据需要更改
双距离=线宽（起点、中点）/4；//设置为边长/4
//表示从中点到新点的x和y的变化
Point2D deltaXY=新点（中点、距离、角度）；
//获得并返回2个新点
返回新的点2D[]{
新的Point2D（middpoint.getX（）+deltaXY.getX（），middpoint.getY（）+deltaXY.getY（）），
新的Point2D（middpoint.getX（）-deltaXY.getX（），middpoint.getY（）-deltaXY.getY（））
};
}
//两点之间的中点
专用静态点2D线条中点（点2D p1、点2D p2）{
返回新的点2d（（p1.getX（）+p2.getX（））/
2，（p1.getY（）+p2.getY（））/2）；
}
//由两点表示的直线的弧度角
专用静态双线角（点2D起点、点2D终点）{
double deltaY=start.getY（）-end.getY（）；
double deltaX=end.getX（）-start.getX（）；
返回数学atan2（deltaY、deltaX）；
}
//由两点表示的直线的长度
专用静态双线长度（点2D起点、点2D终点）{
double deltaY=end.getY（）-start.getY（）；
double deltaX=end.getX（）-start.getX（）；
返回Math.sqrt（deltaY*deltaY+deltaX*deltaX）；
}
//在与点p的距离处构造一个新点。角度表示
//线p的角度为on。
专用静态点2D新点（点2D p，双距离，双角度）{
双三角=距离*数学cos（角度）；
双增量=距离*数学sin（角度）；
返回新的Point2D（deltaX、deltaY）；
}
}

使用javafx

Line

和

Point2D

可以更容易地可视化javafx应用程序上的边缘：

---

但是，

Line

和

Point2D

只是简单的数据结构，可以很容易地替换。

当然有无限多这样的可能边，您需要定义停止条件。你是在问如何生成一定数量的边吗？当然，这样的边是无限多的，你需要定义一个停止条件。您是否在问如何生成一定数量的边？它是二维的还是三维的（我看到

getElevation（）

它建议三维的）。您是否使用gui（swing或javafx）来显示路径？@c0因为停止标准基本上是在A和B之间，我只设置X个步骤，所以从A到B的9个总点表示将边减半3次……这很好，只是现在尝试了一下，效果很好，如果再进一步，是否会有一个“简单”的步骤通用电气的方式