使用 Spring Boot + Geodesy 实现地理空间高精度坐标处理及多样化的距离计算功能

前言

之前我们计算地理空间点位之间的距离等操作,是使用mysql自带的函数进行处理,这样的话需要每个操作都要单独编写一个sql语句,非常的麻烦并且时间查询较慢,效率比较低,今天我们使用 Spring Boot + Geodesy 实现地理空间高精度坐标处理及多样化的距离计算功能,更加方便快捷。

这是之前使用mysql进行简单空间操作的文章：mysql中point的使用

一、Geodesy 框架介绍与特性

Geodesy 是一个专注于地理空间计算的强大框架。它具有以下突出特性：

1.高精度坐标处理：能够精确处理和转换不同的地理坐标系统，确保坐标数据的准确性和一致性。

2.多样化的距离计算方法：支持多种距离计算模式，如直线距离、测地线距离等，满足各种复杂的业务需求。
3.强大的空间分析能力：可以进行空间关系的判断，如点与区域的包含关系、区域之间的相交关系等。
4.高效性能：在处理大规模地理数据时，能保持高效的计算速度和低内存消耗。
5.跨平台兼容性：可以在不同的操作系统和开发环境中稳定运行。

这些特性使得 Geodesy 在地理信息系统、导航应用、物流规划等领域具有广泛的应用价值。在许多应用场景中，需要计算两个地点之间的距离。本文将介绍如何使用 Spring Boot 结合 Geodesy 库来实现距离计算功能。

二、具体实现

项目创建及依赖配置（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>distance-calculation-system</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Distance Calculation System</name>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.gavaghan</groupId>
            <artifactId>geodesy</artifactId>
            <version>1.1.3</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

服务类

package com.icoderoad.service;

import org.gavaghan.geodesy.Ellipsoid;
import org.gavaghan.geodesy.GeodeticCalculator;
import org.gavaghan.geodesy.GeodeticCurve;
import org.gavaghan.geodesy.GlobalCoordinates;

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

public class GeospatialCalculationService {

//计算直线距离
    public double calculateStraightLineDistance(double latitude1, double longitude1, double latitude2, double longitude2) {
        GlobalCoordinates point1 = new GlobalCoordinates(latitude1, longitude1);
        GlobalCoordinates point2 = new GlobalCoordinates(latitude2, longitude2);

        double distance = Math.sqrt(Math.pow((latitude2 - latitude1), 2) + Math.pow((longitude2 - longitude1), 2));
        return distance;
    }
//计算测地距离(三维空间中最短距离)
    public double calculateGeodesicDistance(double latitude1, double longitude1, double latitude2, double longitude2) {
        GlobalCoordinates point1 = new GlobalCoordinates(latitude1, longitude1);
        GlobalCoordinates point2 = new GlobalCoordinates(latitude2, longitude2);

        GeodeticCalculator calculator = new GeodeticCalculator();
        GeodeticCurve curve = calculator.calculateGeodeticCurve(Ellipsoid.WGS84, point1, point2);

        return curve.getEllipsoidalDistance();
    }
//是否为区域内的点
    public boolean isPointInRegion(double pointLatitude, double pointLongitude, List<GlobalCoordinates> regionPoints) {
        // 假设区域是凸多边形
        int n = regionPoints.size();
        boolean inside = false;

        for (int i = 0, j = n - 1; i < n; j = i++) {
            if (((regionPoints.get(i).getLatitude() > pointLatitude)!= (regionPoints.get(j).getLatitude() > pointLatitude))
                    && (pointLongitude < (regionPoints.get(j).getLongitude() - regionPoints.get(i).getLongitude())
                    * (pointLatitude - regionPoints.get(i).getLatitude())
                    / (regionPoints.get(j).getLatitude() - regionPoints.get(i).getLatitude())
                    + regionPoints.get(i).getLongitude())) {
                inside =!inside;
            }
        }
        return inside;
    }
//区域是否相交
    public boolean isRegionIntersect(List<GlobalCoordinates> region1Points, List<GlobalCoordinates> region2Points) {
        // 简单判断，假设两个区域都是凸多边形且边界不相交
        for (GlobalCoordinates point1 : region1Points) {
            if (isPointInRegion(point1.getLatitude(), point1.getLongitude(), region2Points)) {
                return true;
            }
        }
        for (GlobalCoordinates point2 : region2Points) {
            if (isPointInRegion(point2.getLatitude(), point2.getLongitude(), region1Points)) {
                return true;
            }
        }
        return false;
    }
//计算面积
    public double calculateArea(List<GlobalCoordinates> polygonPoints) {
        double area = 0.0;
        int n = polygonPoints.size();

        for (int i = 0; i < n; i++) {
            int j = (i + 1) % n;
            area += polygonPoints.get(i).getLongitude() * polygonPoints.get(j).getLatitude()
                    - polygonPoints.get(j).getLongitude() * polygonPoints.get(i).getLatitude();
        }
        area /= 2.0;
        return Math.abs(area);
    }
}

控制器类

package com.icoderoad.controller;

import com.icoderoad.service.GeospatialCalculationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/geospatial")
public class GeospatialController {

    @Autowired
    private GeospatialCalculationService geospatialCalculationService;

//计算直线距离
    @GetMapping("/calculateStraightLineDistance")
    public double calculateStraightLineDistance(@RequestParam double latitude1, @RequestParam double longitude1,
                                               @RequestParam double latitude2, @RequestParam double longitude2) {
        return geospatialCalculationService.calculateStraightLineDistance(latitude1, longitude1, latitude2, longitude2);
    }
//计算测地距离(三维空间中最短距离)
    @GetMapping("/calculateGeodesicDistance")
    public double calculateGeodesicDistance(@RequestParam double latitude1, @RequestParam double longitude1,
                                           @RequestParam double latitude2, @RequestParam double longitude2) {
        return geospatialCalculationService.calculateGeodesicDistance(latitude1, longitude1, latitude2, longitude2);
    }
//是否为区域内的点
    @GetMapping("/isPointInRegion")
    public boolean isPointInRegion(@RequestParam double pointLatitude, @RequestParam double pointLongitude,
                                  @RequestParam List<Double> regionLatitudes, @RequestParam List<Double> regionLongitudes) {
        List<GlobalCoordinates> regionPoints = new ArrayList<>();
        for (int i = 0; i < regionLatitudes.size(); i++) {
            regionPoints.add(new GlobalCoordinates(regionLatitudes.get(i), regionLongitudes.get(i)));
        }
        return geospatialCalculationService.isPointInRegion(pointLatitude, pointLongitude, regionPoints);
    }
//区域是否相交
    @GetMapping("/isRegionIntersect")
    public boolean isRegionIntersect(@RequestParam List<Double> region1Latitudes, @RequestParam List<Double> region1Longitudes,
                                    @RequestParam List<Double> region2Latitudes, @RequestParam List<Double> region2Longitudes) {
        List<GlobalCoordinates> region1Points = new ArrayList<>();
        List<GlobalCoordinates> region2Points = new ArrayList<>();

        for (int i = 0; i < region1Latitudes.size(); i++) {
            region1Points.add(new GlobalCoordinates(region1Latitudes.get(i), region1Longitudes.get(i)));
        }

        for (int i = 0; i < region2Latitudes.size(); i++) {
            region2Points.add(new GlobalCoordinates(region2Latitudes.get(i), region2Longitudes.get(i)));
        }

        return geospatialCalculationService.isRegionIntersect(region1Points, region2Points);
    }
//计算面积
    @GetMapping("/calculateArea")
    public double calculateArea(@RequestParam List<Double> polygonLatitudes, @RequestParam List<Double> polygonLongitudes) {
        List<GlobalCoordinates> polygonPoints = new ArrayList<>();
        for (int i = 0; i < polygonLatitudes.size(); i++) {
            polygonPoints.add(new GlobalCoordinates(polygonLatitudes.get(i), polygonLongitudes.get(i)));
        }
        return geospatialCalculationService.calculateArea(polygonPoints);
    }
}