java大面积车辆聚集算法实现

最新推荐文章于 2024-07-15 03:12:27 发布
最新推荐文章于 2024-07-15 03:12:27 发布
阅读量1k 收藏 8
点赞数 2
文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lemon_MY/article/details/128953890
版权

需求

对所有车辆位置数据进行汇总判断是否出现大面积聚集停放车辆（一般指半径XX米内集中停放超过XX天，车辆总数大于XX辆）情况。

实现

  1. 点聚合算法（直接距离法）
    将所有的点转换成一个个聚合簇。遍历所有的点，判断是否有聚合簇可以聚合该点（点和聚合簇中心点之间的距离小于给定的半径），选择相离最近的一个聚合簇进行聚合，若该点不可以被聚合簇进行聚合，则单独作为一个聚合簇。

核心代码：

private double r = 500;

/**
* 缺点：各个点迭代顺序不同导致最终结果会有差异
*/
public void directDistance() {
	// 查询所有需要聚合的坐标
	List<Map<String, Object>> list = userMapper.selectUser3();
	List<Point> points = new ArrayList<>();
	// 将所有坐标转换成对象集合
	list.forEach(data -> points.add(Point.builder().latitude(Double.parseDouble(data.get("lat").toString()))
	        .longitude(Double.parseDouble(data.get("lng").toString())).build()));
	// 聚合簇结果集
	List<Cluster> clusters = new ArrayList<>();
	int count = 0;
	// 遍历所有的点
	for (Point point : points) {
	    // 判断是否有聚合簇可以聚合该点
	    Cluster isCluster = null;
	    for (Cluster cluster : clusters) {
	        // 判断点是否在聚合簇的矩形范围内,如果在的话才进行下一步的距离判断
	        // 优化点：不以圆来判断,就使用矩形进行范围判断
	        if(cluster.getLatLngBounds().contains(point)) {
	            double distance = calculateLineDistance(point, cluster.getCenterPoint());
	            // 判断该点和聚合簇中心点之间距离是否小于指定半径(可能有多个聚合簇满足条件,选择相离最近的一个进行聚合)
	            // 优化点：就以第一个相邻的聚合簇进行聚合
	            if (distance < r && (isCluster == null || calculateLineDistance(point, cluster.getCenterPoint()) <
	                    calculateLineDistance(point, isCluster.getCenterPoint()))) {
	                isCluster = cluster;
	            }
	        }
	        count++;
	    }
	
	    if (isCluster != null) {
	        // 该点可以被聚合簇进行聚合
	        isCluster.addCount();
	        isCluster.getPoints().add(point);
	        // 重置中心点和矩形经纬度范围(比较耗时)
	        // 优化点：就以第一个点的坐标作为中心进行聚合
	        isCluster.setCenterPoint(getCenterPoint(isCluster.getPoints()));
	        isCluster.setLatLngBounds(LatLngBounds.builder()
	                .northeast(Point.builder().latitude(point.getLatitude() + km2Degree(r / 1000))
	                        .longitude(point.getLongitude() + km2Degree(r / 1000)).build())
	                .southwest(Point.builder().latitude(point.getLatitude() - km2Degree(r / 1000))
	                        .longitude(point.getLongitude() - km2Degree(r / 1000)).build()).build());
	    } else {
	        // 该点不可以被聚合簇进行聚合,单独作为一个聚合簇添加到集合中
	        clusters.add(Cluster.builder().centerPoint(point).points(CollUtil.newLinkedList(point)).count(1)
	                .latLngBounds(LatLngBounds.builder()
	                        .northeast(Point.builder().latitude(point.getLatitude() + km2Degree(r / 1000))
	                                .longitude(point.getLongitude() + km2Degree(r / 1000)).build())
	                        .southwest(Point.builder().latitude(point.getLatitude() - km2Degree(r / 1000))
	                                .longitude(point.getLongitude() - km2Degree(r / 1000)).build()).build()).build());
	    }
	}
	
	// 是否出现半径500米内集中停放超过60天且SOC大于80%，车辆总数大于100辆的情况
	int vinCount = 0;
	for (Cluster cluster : clusters) {
	    if(cluster.getPoints().size() > 100){
	        vinCount++;
	    }
	}
}

/**
* 计算两点的距离
*/
private double calculateLineDistance(Point source, Point target) {
   double sourceLongitude = source.getLongitude();
   double sourceLatitude = source.getLatitude();
   double targetLongitude = target.getLongitude();
   double targetLatitude = target.getLatitude();
   sourceLatitude = sourceLatitude * Math.PI / 180.0;
   targetLatitude = targetLatitude * Math.PI / 180.0;
   //地球半径
   double r = 6378137;
   double a = sourceLatitude - targetLatitude;
   double b = (sourceLongitude - targetLongitude) * Math.PI / 180.0;
   double sa2 = Math.sin(a / 2.0);
   double sb2 = Math.sin(b / 2.0);
   return 2 * r * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(sourceLatitude) * Math.cos(targetLatitude) * sb2 * sb2));
}

/**
* 取多个经纬度的中心点
*/
public Point getCenterPoint(List<Point> pointList) {

   int total = pointList.size();
   double X = 0, Y = 0, Z = 0;

   for (Point point : pointList) {
       double lat, lng, x, y, z;
       lat = point.getLatitude() * Math.PI / 180;
       lng = point.getLongitude() * Math.PI / 180;
       x = Math.cos(lat) * Math.cos(lng);
       y = Math.cos(lat) * Math.sin(lng);
       z = Math.sin(lat);
       X += x;
       Y += y;
       Z += z;
   }

   X = X / total;
   Y = Y / total;
   Z = Z / total;
   double Lon = Math.atan2(Y, X);
   double Hyp = Math.sqrt(X * X + Y * Y);
   double Lat = Math.atan2(Z, Hyp);
   double longitude = Lon * 180 / Math.PI;
   double latitude = Lat * 180 / Math.PI;
   return Point.builder().longitude(longitude).latitude(latitude).build();
}

/**
* 地球半径:km
*/
public final double earthRadius = 6371.393;

/**
* 将公里数转换为度数
*/
public Double km2Degree(Double l) {
   //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
   //转换后的公式：degree（圆心角）=l(弧长) × 180/(π（圆周率）× r（半径）)
   return (180 / earthRadius / Math.PI) * l;
}

/**
* 将度数转换为公里数
*/
public Double degree2Km(Double degree) {
   //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
   //将180放在前面，降低数值
   return earthRadius / 180 * Math.PI * degree;
}

实体类：

public class DirectUtil {

    /**
     * 计算两点的距离
     */
    private double calculateLineDistance(Point source, Point target) {
        double sourceLongitude = source.getLongitude();
        double sourceLatitude = source.getLatitude();
        double targetLongitude = target.getLongitude();
        double targetLatitude = target.getLatitude();
        sourceLatitude = sourceLatitude * Math.PI / 180.0;
        targetLatitude = targetLatitude * Math.PI / 180.0;
        //地球半径
        double r = 6378137;
        double a = sourceLatitude - targetLatitude;
        double b = (sourceLongitude - targetLongitude) * Math.PI / 180.0;
        double sa2 = Math.sin(a / 2.0);
        double sb2 = Math.sin(b / 2.0);
        return 2 * r * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(sourceLatitude) * Math.cos(targetLatitude) * sb2 * sb2));
    }

    /**
     * 取多个经纬度的中心点
     */
    public Point getCenterPoint(List<Point> pointList) {

        int total = pointList.size();
        double X = 0, Y = 0, Z = 0;

        for (Point point : pointList) {
            double lat, lng, x, y, z;
            lat = point.getLatitude() * Math.PI / 180;
            lng = point.getLongitude() * Math.PI / 180;
            x = Math.cos(lat) * Math.cos(lng);
            y = Math.cos(lat) * Math.sin(lng);
            z = Math.sin(lat);
            X += x;
            Y += y;
            Z += z;
        }

        X = X / total;
        Y = Y / total;
        Z = Z / total;
        double Lon = Math.atan2(Y, X);
        double Hyp = Math.sqrt(X * X + Y * Y);
        double Lat = Math.atan2(Z, Hyp);
        double longitude = Lon * 180 / Math.PI;
        double latitude = Lat * 180 / Math.PI;
        return Point.builder().longitude(longitude).latitude(latitude).build();
    }

    /**
     * 地球半径:km
     */
    public final double earthRadius = 6371.393;

    /**
     * 将公里数转换为度数
     */
    public Double km2Degree(Double l) {
        //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
        //转换后的公式：degree（圆心角）=l(弧长) × 180/(π（圆周率）× r（半径）)
        return (180 / earthRadius / Math.PI) * l;
    }

    /**
     * 将度数转换为公里数
     */
    public Double degree2Km(Double degree) {
        //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
        //将180放在前面，降低数值
        return earthRadius / 180 * Math.PI * degree;
    }

    /**
     * 判断是否出现车辆聚集的情况
     */
    private boolean directDistance(double r, int vinCount, List<Point> points){
        // 聚合簇结果集
        List<Cluster> clusters = new ArrayList<>();
        // 遍历所有的点
        for (Point point : points) {
            // 判断是否有聚合簇可以聚合该点
            Cluster isCluster = null;
            for (Cluster cluster : clusters) {
                // 判断点是否在聚合簇的矩形范围内,如果在的话才进行下一步的距离判断
                // 优化点：不以圆来判断,就使用矩形进行范围判断
                if(cluster.getLatLngBounds().contains(point)) {
                    double distance = calculateLineDistance(point, cluster.getCenterPoint());
                    // 判断该点和聚合簇中心点之间距离是否小于指定半径(可能有多个聚合簇满足条件,选择相离最近的一个进行聚合)
                    // 优化点：就以第一个相邻的聚合簇进行聚合
                    if (distance < r && (isCluster == null || calculateLineDistance(point, cluster.getCenterPoint()) <
                            calculateLineDistance(point, isCluster.getCenterPoint()))) {
                        isCluster = cluster;
                    }
                }
            }

            if (isCluster != null) {
                // 该点可以被聚合簇进行聚合
                isCluster.addCount();
                isCluster.getPoints().add(point);
                // 重置中心点和矩形经纬度范围(比较耗时)
                // 优化点：就以第一个点的坐标作为中心进行聚合
                isCluster.setCenterPoint(getCenterPoint(isCluster.getPoints()));
                isCluster.setLatLngBounds(LatLngBounds.builder()
                        .northeast(Point.builder().latitude(point.getLatitude() + km2Degree(r / 1000))
                                .longitude(point.getLongitude() + km2Degree(r / 1000)).build())
                        .southwest(Point.builder().latitude(point.getLatitude() - km2Degree(r / 1000))
                                .longitude(point.getLongitude() - km2Degree(r / 1000)).build()).build());
            } else {
                // 该点不可以被聚合簇进行聚合,单独作为一个聚合簇添加到集合中
                clusters.add(Cluster.builder().centerPoint(point).points(CollUtil.newLinkedList(point)).count(1)
                        .latLngBounds(LatLngBounds.builder()
                                .northeast(Point.builder().latitude(point.getLatitude() + km2Degree(r / 1000))
                                        .longitude(point.getLongitude() + km2Degree(r / 1000)).build())
                                .southwest(Point.builder().latitude(point.getLatitude() - km2Degree(r / 1000))
                                        .longitude(point.getLongitude() - km2Degree(r / 1000)).build()).build()).build());
            }
        }
        // 判断是否出现车辆聚集的情况
        for (Cluster cluster : clusters) {
            if(cluster.getPoints().size() > vinCount){
                // 出现聚集
                return true;
            }
        }

        return false;
    }
}

@Data
@Builder
public class Cluster implements Serializable {

    /**
     * 该聚合簇根据中心点及圆半径得到的的矩形经纬度范围
     */
    LatLngBounds latLngBounds;

    /**
     * 该聚合簇圆半径中心
     */
    private Point centerPoint;

    /**
     * 该聚合簇包含的点
     */
    private List<Point> points;

    /**
     * 该聚合簇包含的点个数
     */
    private int count;

    public void addCount() {
        this.count++;
    }
}

@Data
@Builder
public class LatLngBounds {

    /**
     * 西南的经纬度
     */
    private Point southwest;

    /**
     * 东北的经纬度
     */
    private Point northeast;

    public boolean contains(Point point) {
        return this.checkLatitude(point.getLatitude()) && this.checkLongitude(point.getLongitude());
    }

    private boolean checkLatitude(double latitude) {
        return this.southwest.getLatitude() <= latitude && latitude <= this.northeast.getLatitude();
    }

    private boolean checkLongitude(double longitude) {
        return this.southwest.getLongitude() <= longitude && longitude <= this.northeast.getLongitude();
    }
}

@Data
@Builder
public class Point implements Serializable {

    /**
     * 经度
     */
    private double longitude;

    /**
     * 纬度
     */
    private double latitude;
}
  1. DBSCAN算法
    直观效果上看，DBSCAN算法可以找到样本点的全部密集区域，并把这些密集区域当做一个一个的聚类簇。指定领域半径为给定的半径，邻域中数据对象数目阈值为给定的车辆数上限，计算得到所有满足条件的聚类簇。将这些聚类簇的边缘点的经纬度化作一个矩形， 计算这个矩形是小于所给半径圆。若矩形比所给半径圆大，还需对该矩形进行划分判断（使用点聚合算法），是否有某一块满足半径XX米内且车辆总数大于XX辆。（由于DBSCAN算法直接对整个数据集进行操作，并且在聚类之前需要建立相应的R*树，并绘制k-dist图，因此算法所需的内存空间和I/O消耗都相当可观。在计算资源有限而数据量又非常庞大的情况下，DBSCAN算法的效率将受到很大影响。DBSCAN算法将区域查询得到的所有未被处理过的点都作为种子点，留待下一步扩展处理。对于大规模数据集中的较大类而言，这种策略会使种子点的数目不断膨胀，算法所需的内存空间也会快速增加。）

核心代码：

private double r = 1000;

/**
 * 慢,并且非常耗内存,28000的数据就出现内存溢出
 */
public void dbScan() throws Exception {
    // 查询所有需要聚合的坐标
    List<Map<String, Object>> list = userMapper.selectUser3();
    List<CustomerPoint> points = new LinkedList<>();
    // 将所有坐标转换成对象集合
    list.forEach(data -> points.add(new CustomerPoint(new double[]{Double.parseDouble(data.get("lat").toString()),
            Double.parseDouble(data.get("lng").toString())})));

    //这里第一个参数为距离，第二个参数为最小邻居数量
    DBScanUtil db = new DBScanUtil(r, 1);
    //返回结果并打印
    List<List<CustomerPoint>> aa =db.cluster(points);
}

实体类：

public class DBScanUtil {

    /**
     * 邻域半径
     */
    private final double distance;

    /**
     * 邻域中数据对象数目阈值
     */
    private final int minPoints;

    /**
     * 标记每个点的状态
     */
    private final Map<CustomerPoint, PointStatus> visited = new HashMap<>();


    public DBScanUtil(final double distance, final int minPoints)
            throws Exception {
        if (distance < 0.0d) {
            throw new Exception("距离小于0");
        }
        if (minPoints < 0) {
            throw new Exception("点数小于0");
        }
        this.distance = distance;
        this.minPoints = minPoints;
    }

    /**
     * 返回customerPoint的多个聚合
     */
    public List<List<CustomerPoint>> cluster(List<CustomerPoint> points) {

        final List<List<CustomerPoint>> clusters = new ArrayList<>();

        for (CustomerPoint point : points) {
            //如果已经被标记(已被使用非空闲点)
            if (visited.get(point) != null) {
                continue;
            }
            //找出所有从该点密度可达的数据对象点,形成一个簇
            List<CustomerPoint> neighbors = getNeighbors(point, points);
            if (neighbors.size() >= minPoints) {
                //邻域半径R内的点的个数大于最少点数目minpoints,密集
                //更新点标记状态
                visited.put(point, PointStatus.POINT);
                List<CustomerPoint> cluster = new ArrayList<>();
                //遍历所有邻居继续拓展找点
                clusters.add(expandCluster(cluster, point, neighbors, points, visited));
            } else {
                //达不到密集状态,该点为边缘点
                visited.put(point, PointStatus.NOISE);
            }
        }

        return clusters;
    }


    private List<CustomerPoint> expandCluster(List<CustomerPoint> cluster,
                                              CustomerPoint point,
                                              List<CustomerPoint> neighbors,
                                              List<CustomerPoint> points,
                                              Map<CustomerPoint, PointStatus> visited) {
        cluster.add(point);
        //遍历所有的邻居
        for (CustomerPoint current : neighbors) {
            PointStatus pStatus = visited.get(current);
            //该点未被标记,为空闲点,将该点的邻居纳入聚簇范围内
            if (pStatus == null) {
                List<CustomerPoint> currentNeighbors = getNeighbors(current, points);
                neighbors.addAll(currentNeighbors);
            }
            //该点未被其他聚簇纳入,纳入本聚簇,更新点标记状态
            if (pStatus != PointStatus.POINT) {
                visited.put(current, PointStatus.POINT);
                cluster.add(current);
            }
        }
        return cluster;
    }

    //找到所有的邻居
    private List<CustomerPoint> getNeighbors(CustomerPoint point, List<CustomerPoint> points) {
        List<CustomerPoint> neighbors = new ArrayList<>();
        for (CustomerPoint neighbor : points) {
            if (visited.get(neighbor) != null) {
                continue;
            }
            if (point != neighbor && neighbor.distanceFrom(point) <= distance) {
                neighbors.add(neighbor);
            }
        }
        return neighbors;
    }

    //做数据进行测试
    public static void main(String[] args) throws Exception {
        CustomerPoint customerPoint = new CustomerPoint(new double[]{3, 8});
        CustomerPoint customerPoint1 = new CustomerPoint(new double[]{4, 7});
        CustomerPoint customerPoint2 = new CustomerPoint(new double[]{4, 8});
        CustomerPoint customerPoint3 = new CustomerPoint(new double[]{5, 6});
        CustomerPoint customerPoint4 = new CustomerPoint(new double[]{3, 9});
        CustomerPoint customerPoint5 = new CustomerPoint(new double[]{5, 1});
        CustomerPoint customerPoint6 = new CustomerPoint(new double[]{5, 2});
        CustomerPoint customerPoint7 = new CustomerPoint(new double[]{6, 3});
        CustomerPoint customerPoint8 = new CustomerPoint(new double[]{7, 3});
        CustomerPoint customerPoint9 = new CustomerPoint(new double[]{7, 4});
        CustomerPoint customerPoint10 = new CustomerPoint(new double[]{0, 2});
        CustomerPoint customerPoint11 = new CustomerPoint(new double[]{8, 16});
        CustomerPoint customerPoint12 = new CustomerPoint(new double[]{1, 1});
        CustomerPoint customerPoint13 = new CustomerPoint(new double[]{1, 3});

        List<CustomerPoint> cs = new ArrayList<>();
        cs.add(customerPoint13);
        cs.add(customerPoint12);
        cs.add(customerPoint11);
        cs.add(customerPoint10);
        cs.add(customerPoint9);
        cs.add(customerPoint8);
        cs.add(customerPoint7);
        cs.add(customerPoint6);
        cs.add(customerPoint5);
        cs.add(customerPoint4);
        cs.add(customerPoint3);
        cs.add(customerPoint2);
        cs.add(customerPoint1);
        cs.add(customerPoint);
        //这里第一个参数为距离，第二个参数为最小邻居数量
        DBScanUtil db = new DBScanUtil(1.5, 1);
        //返回结果并打印
        List<List<CustomerPoint>> aa = db.cluster(cs);
        for (int i = 0; i < aa.size(); i++) {
            for (int j = 0; j < aa.get(i).size(); j++) {
                System.out.print(aa.get(i).get(j).toString());
            }
            System.out.println();
        }
    }
}

public class CustomerPoint implements Clusterable<CustomerPoint> {

    private final double[] point;

    public CustomerPoint(final double[] point) {
        this.point = point;
    }

    public double[] getPoint() {
        return point;
    }

    public double distanceFrom(final CustomerPoint p) {
        return MathUtils.distance(point, p.getPoint());
    }

    public CustomerPoint centroidOf(final Collection<CustomerPoint> points) {
        double[] centroid = new double[getPoint().length];
        for (CustomerPoint p : points) {
            for (int i = 0; i < centroid.length; i++) {
                centroid[i] += p.getPoint()[i];
            }
        }
        for (int i = 0; i < centroid.length; i++) {
            centroid[i] /= points.size();
        }
        return new CustomerPoint(centroid);
    }

    @Override
    public int hashCode() {
        return Arrays.hashCode(point);
    }

    @Override
    public boolean equals(final Object other) {
        if (!(other instanceof CustomerPoint)) {
            return false;
        }
        final double[] otherPoint = ((CustomerPoint) other).getPoint();
        if (point.length != otherPoint.length) {
            return false;
        }
        for (int i = 0; i < point.length; i++) {
            if (point[i] != otherPoint[i]) {
                return false;
            }
        }
        return true;
    }
    @Override
    public String toString() {
        final StringBuffer buff = new StringBuffer("{");
        final double[] coordinates = getPoint();
        buff.append("lat:"+coordinates[0]+",");
        buff.append("lng:"+coordinates[1]+",");
        buff.append("}");
        return buff.toString();
    }
}

public enum PointStatus {

    //点的标记，point:聚簇内的点，noise：噪音点
    NOISE, POINT
}
  1. 网格距离算法
    找出所有经纬度中最大和最小的，构成一个正方形，将正方形按照半径XX进行切割，根据每个落在不同正方形中的点算出该正方形的质心，遍历这些质心，对于相邻方格内间距小于半径XX的质心进行合并，然后判断质心所含的点是否出现车辆聚集情况。
    核心代码：
private double r = 500;

/**
* 缺点：合并质心的时候可能出现极端点情况
*/
public void gridDistance() {
	// 查询所有需要聚合的坐标
	List<Map<String, Object>> list = userMapper.selectUser3();
	List<Point> points = new ArrayList<>();
	// 将所有坐标转换成对象集合
	list.forEach(data -> points.add(Point.builder().latitude(Double.parseDouble(data.get("lat").toString()))
	        .longitude(Double.parseDouble(data.get("lng").toString())).build()));
	Point point = new Point(0, 0, 0, 0);
	// 根据最大最下经纬度获取矩形
	Rectangle rectangle = new Rectangle(points.stream().max(Comparator.comparing(Point::getLongitude)).orElse(point).getLongitude(),
	        points.stream().min(Comparator.comparing(Point::getLongitude)).orElse(point).getLongitude(),
	        points.stream().max(Comparator.comparing(Point::getLatitude)).orElse(point).getLatitude(),
	        points.stream().min(Comparator.comparing(Point::getLatitude)).orElse(point).getLatitude());
	// 网格横纵坐标及对应的网格集合
	Map<String, ShortRectangle> shortRectangles = new HashMap<>();
	// 遍历坐标点,计算横纵坐标
	points.forEach(item -> {
	    item.setWide((int) Math.floor((item.getLongitude() - rectangle.getMinLongitude()) / km2Degree(r / 1000)));
	    item.setLength((int) Math.floor((item.getLatitude() - rectangle.getMinLatitude()) / km2Degree(r / 1000)));
	    // 网格横纵坐标
	    String coordinate = item.getLength() + "-" + item.getWide();
	    if (shortRectangles.get(coordinate) == null) {
	        // 如果网格集合中还没有该网格的数据
	        shortRectangles.put(coordinate, ShortRectangle.builder().length(item.getLength()).wide(item.getWide())
	                .count(1).points(ListUtil.toLinkedList(item)).build());
	    } else {
	        // 更新网格数据
	        ShortRectangle shortRectangle = shortRectangles.get(coordinate);
	        shortRectangle.addCount();
	        shortRectangle.getPoints().add(item);
	        shortRectangles.put(coordinate, shortRectangle);
	    }
	});
	// 遍历网格集合,计算质心
	List<ShortRectangle> data = CollUtil.newArrayList(shortRectangles.values());
	data.forEach(item -> item.setCentroid(getCenterPoint(item.getPoints())));
	// 遍历质心,判断是否出现车辆聚集的情况
	int vinCount = 0;
	for (ShortRectangle shortRectangle : data) {
	    // 聚集车辆数
	    int num = shortRectangle.getCount();
	    for (ShortRectangle shortRectangle2 : data) {
	        // 判断是否是相邻网格的质心
	        int lengthAbs = Math.abs(shortRectangle2.getLength() - shortRectangle.getLength());
	        int wideAbs = Math.abs(shortRectangle2.getWide() - shortRectangle.getWide());
	        double v = Math.pow(lengthAbs, 2) + Math.pow(wideAbs, 2);
	        if (v >= 1 && v <= 2 && calculateLineDistance(shortRectangle.getCentroid(), shortRectangle2.getCentroid()) < r) {
	            num += shortRectangle2.getCount();
	        }
	    }
	    if (num > 100) {
	        // 出现聚集
	        vinCount++;
	    }
	}
}

/**
 * 取多个经纬度的中心点
 */
public Point getCenterPoint(List<Point> pointList) {

    int total = pointList.size();
    double X = 0, Y = 0, Z = 0;

    for (Point point : pointList) {
        double lat, lng, x, y, z;
        lat = point.getLatitude() * Math.PI / 180;
        lng = point.getLongitude() * Math.PI / 180;
        x = Math.cos(lat) * Math.cos(lng);
        y = Math.cos(lat) * Math.sin(lng);
        z = Math.sin(lat);
        X += x;
        Y += y;
        Z += z;
    }

    X = X / total;
    Y = Y / total;
    Z = Z / total;
    double Lon = Math.atan2(Y, X);
    double Hyp = Math.sqrt(X * X + Y * Y);
    double Lat = Math.atan2(Z, Hyp);
    double longitude = Lon * 180 / Math.PI;
    double latitude = Lat * 180 / Math.PI;
    return Point.builder().longitude(longitude).latitude(latitude).build();
}

/**
 * 计算两点的距离
 */
private double calculateLineDistance(Point source, Point target) {
    double sourceLongitude = source.getLongitude();
    double sourceLatitude = source.getLatitude();
    double targetLongitude = target.getLongitude();
    double targetLatitude = target.getLatitude();
    sourceLatitude = sourceLatitude * Math.PI / 180.0;
    targetLatitude = targetLatitude * Math.PI / 180.0;
    //地球半径
    double r = 6378137;
    double a = sourceLatitude - targetLatitude;
    double b = (sourceLongitude - targetLongitude) * Math.PI / 180.0;
    double sa2 = Math.sin(a / 2.0);
    double sb2 = Math.sin(b / 2.0);
    return 2 * r * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(sourceLatitude) * Math.cos(targetLatitude) * sb2 * sb2));
}

/**
 * 地球半径:km
 */
public final double earthRadius = 6371.393;

/**
 * 将公里数转换为度数
 */
public Double km2Degree(Double l) {
    //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
    //转换后的公式：degree（圆心角）=l(弧长) × 180/(π（圆周率）× r（半径）)
    return (180 / earthRadius / Math.PI) * l;
}

/**
 * 将度数转换为公里数
 */
public Double degree2Km(Double degree) {
    //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
    //将180放在前面，降低数值
    return earthRadius / 180 * Math.PI * degree;
}

实体类：

public class GridUtil {

    /**
     * 地球半径:km
     */
    private final double earthRadius = 6371.393;

    /**
     * 将公里数转换为度数
     */
    private Double km2Degree(Double l) {
        //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
        //转换后的公式：degree（圆心角）=l(弧长) × 180/(π（圆周率）× r（半径）)
        return (180 / earthRadius / Math.PI) * l;
    }

    /**
     * 将度数转换为公里数
     */
    private Double degree2Km(Double degree) {
        //公式:l(弧长)=degree（圆心角）× π（圆周率）× r（半径）/180
        //将180放在前面，降低数值
        return earthRadius / 180 * Math.PI * degree;
    }

    /**
     * 取多个经纬度的中心点
     */
    private Point getCenterPoint(List<Point> pointList) {

        int total = pointList.size();
        double X = 0, Y = 0, Z = 0;

        for (Point point : pointList) {
            double lat, lng, x, y, z;
            lat = point.getLatitude() * Math.PI / 180;
            lng = point.getLongitude() * Math.PI / 180;
            x = Math.cos(lat) * Math.cos(lng);
            y = Math.cos(lat) * Math.sin(lng);
            z = Math.sin(lat);
            X += x;
            Y += y;
            Z += z;
        }

        X = X / total;
        Y = Y / total;
        Z = Z / total;
        double Lon = Math.atan2(Y, X);
        double Hyp = Math.sqrt(X * X + Y * Y);
        double Lat = Math.atan2(Z, Hyp);
        double longitude = Lon * 180 / Math.PI;
        double latitude = Lat * 180 / Math.PI;
        return Point.builder().longitude(longitude).latitude(latitude).build();
    }

    /**
     * 计算两点的距离
     */
    private double calculateLineDistance(Point source, Point target) {
        double sourceLongitude = source.getLongitude();
        double sourceLatitude = source.getLatitude();
        double targetLongitude = target.getLongitude();
        double targetLatitude = target.getLatitude();
        sourceLatitude = sourceLatitude * Math.PI / 180.0;
        targetLatitude = targetLatitude * Math.PI / 180.0;
        //地球半径
        double r = 6378137;
        double a = sourceLatitude - targetLatitude;
        double b = (sourceLongitude - targetLongitude) * Math.PI / 180.0;
        double sa2 = Math.sin(a / 2.0);
        double sb2 = Math.sin(b / 2.0);
        return 2 * r * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(sourceLatitude) * Math.cos(targetLatitude) * sb2 * sb2));
    }

    /**
     * 判断是否出现车辆聚集的情况
     */
    private boolean gridDistance(double r, int vinCount, List<Point> points){
        Point point = new Point(0, 0, 0, 0);
        // 根据最大最下经纬度获取矩形
        Rectangle rectangle = new Rectangle(points.stream().max(Comparator.comparing(Point::getLongitude)).orElse(point).getLongitude(),
                points.stream().min(Comparator.comparing(Point::getLongitude)).orElse(point).getLongitude(),
                points.stream().max(Comparator.comparing(Point::getLatitude)).orElse(point).getLatitude(),
                points.stream().min(Comparator.comparing(Point::getLatitude)).orElse(point).getLatitude());
        // 网格横纵坐标及对应的网格集合
        Map<String, ShortRectangle> shortRectangles = new HashMap<>();
        // 遍历坐标点,计算横纵坐标
        points.forEach(item -> {
            item.setWide((int) Math.floor((item.getLongitude() - rectangle.getMinLongitude()) / km2Degree(r / 1000)));
            item.setLength((int) Math.floor((item.getLatitude() - rectangle.getMinLatitude()) / km2Degree(r / 1000)));
            // 网格横纵坐标
            String coordinate = item.getLength() + "-" + item.getWide();
            if (shortRectangles.get(coordinate) == null) {
                // 如果网格集合中还没有该网格的数据
                shortRectangles.put(coordinate, ShortRectangle.builder().length(item.getLength()).wide(item.getWide())
                        .count(1).points(ListUtil.toLinkedList(item)).build());
            } else {
                // 更新网格数据
                ShortRectangle shortRectangle = shortRectangles.get(coordinate);
                shortRectangle.addCount();
                shortRectangle.getPoints().add(item);
                shortRectangles.put(coordinate, shortRectangle);
            }
        });
        // 遍历网格集合,计算质心
        List<ShortRectangle> data = CollUtil.newArrayList(shortRectangles.values());
        data.forEach(item -> item.setCentroid(getCenterPoint(item.getPoints())));
        // 遍历质心,判断是否出现车辆聚集的情况
        for (ShortRectangle shortRectangle : data) {
            // 聚集车辆数
            int num = shortRectangle.getCount();
            for (ShortRectangle shortRectangle2 : data) {
                // 判断是否是相邻网格的质心
                int lengthAbs = Math.abs(shortRectangle2.getLength() - shortRectangle.getLength());
                int wideAbs = Math.abs(shortRectangle2.getWide() - shortRectangle.getWide());
                double v = Math.pow(lengthAbs, 2) + Math.pow(wideAbs, 2);
                if (v >= 1 && v <= 2 && calculateLineDistance(shortRectangle.getCentroid(), shortRectangle2.getCentroid()) < r) {
                    num += shortRectangle2.getCount();
                }
            }
            if (num > vinCount) {
                // 出现聚集
                return true;
            }
        }

        return false;
    }
}

@Data
@Builder
public class Point implements Serializable {

    /**
     * 经度
     */
    private double longitude;

    /**
     * 纬度
     */
    private double latitude;

    /**
     * 位于矩形的横坐标
     */
    private int length;

    /**
     * 位于矩形的纵坐标
     */
    private int wide;
}

@Data
@AllArgsConstructor
public class Rectangle {

    private double maxLongitude;

    private double minLongitude;

    private double maxLatitude;

    private double minLatitude;
}

@Data
@Builder
public class ShortRectangle {

    /**
     * 小矩形的横坐标
     */
    private int length;

    /**
     * 小矩形的纵坐标
     */
    private int wide;

    /**
     * 该小矩形包含的点个数
     */
    private int count;

    /**
     * 该小矩形包含的点
     */
    private List<Point> points;

    /**
     * 质心
     */
    private Point centroid;

    public void addCount() {
        count++;
    }
}

性能测试

半径越大，点数越多，网格距离法性能越好；
半径越小，点数越少，直接距离法性能越好；
DbScan非常耗内存，不建议使用；

推荐

推荐使用直接距离法和网格距离算法

Lemon_MY
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
电商场景下的机器学习算法：推荐算法分类算法等
程序员光剑
05-01 813
1. 背景介绍 1.1 电商行业的蓬勃发展与挑战 随着互联网的普及和移动支付的兴起，电商行业经历了爆发式增长。海量的商品信息、用户数据以及交易记录为电商平台带来了巨大的机遇，同时也带来了巨大的挑战。如何从海量数据中挖掘有价值的信息，为用户提供个性化的购物体验，提高平台的运营效率，成为电商平台
java kmeans聚合算法
04-21
比如给出1千个坐标，求出这1千个坐标的重心点。 本人从pascal算法转成java
DBSCAN聚类C++算法，可用于GPS车辆聚集计算
02-05
DBSCAN聚类算法，可用于GPS车辆聚集计算 文章请见： http://blog.csdn.net/winnyrain/article/details/52467617
java 对多个坐标点进行汇聚
最新发布
weixin_40202777的博客
07-15 80
Java对多个坐标点进行汇聚 在现代社会中，我们经常需要处理大量的数据并对其进行分析。在很多情况下，这些数据可能是空间数据，比如坐标点。在处理这些坐标点时，我们可能需要对它们进行汇聚，以得出一些有用的信息。本文将介绍如何使用Java对多个坐标点进行汇聚的方法，并结合代码示例进行说明。 什么是坐标点汇聚 坐标点汇聚是指将多个...
java 聚合算法_Java编程算法基础---组合与聚合
weixin_32595533的博客
02-16 373
组合与聚合是类间的最常见的依赖关系。有时，可以只用组合或聚合来代替继承，弱化依赖关系，也可以通过组合或聚合模拟出多继承的效果(java不支持多继承)。 组合与聚合的其区别是：组合的对象在母体消亡时随同一起消亡，而聚合则不然。 举例：　战士和他的心脏是组合关系战士和他的步枪是聚合关系 通过继承ArrayList来解决:package NO3;import java.util.ArrayList...
DBSCAN聚集算法改进，可用于车辆GPS经纬度聚集计算
Leckun的专栏
09-08 1万+
1、DBSCAN简介 DBSCAN（Density-Based Spatial Clustering of Applications with Noise，具有噪声的基于密度的聚类方法）是一种基于密度的空间聚类算法。该算法将具有足够密度的区域划分为簇，并在具有噪声的空间数据库中发现任意形状的簇，它将簇定义为密度相连的点的最大集合。 该算法利用基于密度的聚类的概念，即要求聚类空间中的一定区域内所
java地理坐标-聚类算法 实现DBScan聚类算法
tiger_Angle
07-12 2252
最近有一个需求，在地图上，将客户按照距离进行聚合。比如，a客户到b客户5km，b客户到c客户5km，那么abc就可以聚合成一个集合。首先想到的就是找一个根据坐标来聚合的算法，这里找了一些后来选择了较为简单也符合要求的DBScan聚类算法。 　　它是一种基于密度的聚类算法，简单来说就是根据样本的紧密程度和数量将其分成多个集合。这个样本一般来说是一堆坐标点。参数可以为欧式距离和邻域密度阈值（就是每次寻找相邻的点的最低数量）。最终返回多个样本集合。 java实现 　　坐标点：这个类如果测试的话，只用到里面的
java 画趋势图,java画曲线图
weixin_35698738的博客
03-10 2293
java动态曲线图,2016年 7 个最佳的 java 框架,java画曲线图,java做统计曲线图java 动态曲线图,2016年 7 个最佳的 java 框架,java做统计曲线图,java画曲线图()); 柱状图 DEMO: package com.cons.jfreechart; import java.awt.Color; import java.io.File; import java...
java 数据归一化,数据变换-归一化与标准化
weixin_30045597的博客
03-20 2102
一般在机器学习的模型训练之前，有一个比较重要的步骤是数据变换。因为，一般情况下，原始数据的各个特征的值并不在一个统一的范围内，这样数据之间就没有可比性。数据变换的目的是将不同渠道，不同量级的数据转化到统一的范围之内，方便后续的分析处理。数据变换的方法有很多，比如数据平滑，数据聚集，数据概化，数据规范化和属性构造等。本篇文章主要介绍数据规范化，这是一种比较常用，也比较简单的方法。数据规范化是使属性数...
Java高级工程师常见面试题(答案)
m0_67402235的博客
06-24 2695
2017年02月17日 12:46:00阅读数：17280一、Java基础1. String类为什么是final的。2. HashMap的源码，实现原理，底层结构。总的来说，HashMap就是数组+链表(哈希表或者散列函数)的组合实现，每个数组元素存储一个链表的头结点，本质上来说是哈希表“拉链法”的实现。HashMap的链表元素对应的是一个静态内部类Entry，Entry主要包含key，value，next三个元素主要有put和get方法，put的原理是，通过hash&length-1计算index，此时记
2024华为OD机试真题目录 B+C+D卷，使用Java语言进行解答（484道）
热门推荐
KJ.JK
09-20 3万+
本文是华为OD机试真题（Java 语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
java 代码实现聚类算法
01-26
网上很多python的聚类算法有很多，找的Java的，里面是个jar，直接调用就好了
K中心点聚类算法
12-25
最传统的K中心点聚类算法，具有易陷入局部最优和随机选取质心的缺点
point-clustering.rar Java后端前端进行经纬度点抽稀聚合渲染
10-24
Java后端进行经纬度点抽稀聚合，HTML呈现及前端聚合渲染 index.html 谷歌map后端点聚合 geos.html 后端点聚合并渲染 geo_cluster.html mapbox前端点聚合 jpg/heatJpgTile.html 栅格瓦片jpg渲染底图及数据 multilines.html 多点，线面渲染
地图点聚合
12-24
之前在项目中需要用到百度地图的点聚合，看了百度提供的demo之后，稍微读了一些源码就能达到需求了，所以并未深入解读源码。 最近有空就把百度实现点聚合的源码从里到外仔细研究了一遍受益良多，在此分享一下。
java 数据聚合_GaussDB(DWS) DMS历史监控数据聚合算法java实现
weixin_29054523的博客
02-24 327
GaussDB(DWS) DMS在性能监控时，有聚合数据的需求，JDK自带的SummaryStatistics类自带求和、最大值、最小值、平均值等聚合算法，要实现均值、方差、峰值、偏度等数据聚合方式，需要一个继承SummaryStatistics子类，并在子类中实现相关的算法。代码示例如下：import java.util.DoubleSummaryStatistics;/*** @Descrip...
利用K-means聚类算法根据经纬度坐标对中国省市进行聚类
LLG_llg_llg的博客
11-16 2万+
K-means聚类算法是一种非层次聚类算法，在最小误差的基础上将数据划分了特定的类，类间利用距离作为相似度指标，两个向量之间的距离越小，其相似度就越高。程序读取全国省市经纬度坐标，然后根据经纬度坐标进行K-means聚类分析。
JAVA代码 实现定位数据动态聚集并绘制多边形区域
胖虎儿的博客
03-29 1174
java算法，实现经纬定位数据动态聚集并绘制出对应多边形区域
百度地图 车辆行驶轨迹，使用聚合点 实现轨迹展示，聚合点样式自定义和点击事件，图片旋转方向，
u013890784的博客
09-20 2070
1.获取第一个marker 里面的内容（坐标，图片旋转角度，车牌号 等信息）用来给聚合点做样式的时候使用。 2.,marker 自定义 3.addEventListener， addOverlay，MarkerClusterer， map.addEventListener("zoomend",(p.longitude,p.latitude)
JAVA车辆管理信息系统设计与实现
软件的算法不涉及复杂的数学计算，重点在于对软件模型的分析和设计。 3. 功能设计： - test类：作为启动登录系统的入口。 - LoginFrame类：构建登陆界面，包含用户认证功能。 - 用户成功登录后，进入系统界面，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值