政区四至与地图四至范围聚合效果计算方法

最新推荐文章于 2024-06-18 09:51:17 发布
最新推荐文章于 2024-06-18 09:51:17 发布
阅读量971 收藏 2
点赞数 1
分类专栏： # LBS位置服务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boonya/article/details/107822159
版权

目录

地图屏占比

屏占比算法

矩形求重叠面积算法

聚合计算工具类

聚合效果图

地图聚合屏幕占比 = 政区四至面积/屏幕四至面积x100%. 两个矩形确定一个同位点然后计算两点相交部分的长宽面积即可。

地图屏占比

图形面积与当前四至面积比对占比值，合理的比重是20%。

 

屏占比算法

https://blog.csdn.net/liuzhenya1994/article/details/80870830?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight

F= 矩形面积/地图四至面积* 100%

矩形集已知，轮询计算

  • 小于20% 显示聚合-计算结束
  • 大于20% 继续下级计算，直到计算占比面积小于20%结束，没有下级结束，显示空间点。

两点确定一条直线，两线确定一面

矩形的面积= 长* 宽

geometry多边形的面积 = geometry直接求算 Postgresql有函数

矩形求重叠面积算法

定义矩形

package com.boonya.beans.gis;

import java.io.Serializable;

/**
 * @Copyright: 2019-2021
 * @FileName: Rectangle.java
 * @Author: PJL
 * @Date: 2020/7/14 18:19
 * @Description: 矩形
 */
public class Rectangle implements Comparable<Rectangle>, Serializable {
    private double x; //矩形左下角的x坐标
    private double y; //矩形左下角的y坐标
    private double length;
    private double width;

    public Rectangle(double x, double y, double length, double width) {
        this.x = x;
        this.y = y;
        this.length = length;
        this.width = width;
    }

    public double getArea() {
        return length * width;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getLength() {
        return length;
    }

    public double getWidth() {
        return width;
    }

    @Override
    public int compareTo(Rectangle o) {
        return Double.compare(this.getArea(), o.getArea());
    }
}

定义计算面积方法

package com.boonya.beans.gis;

/**
 * @Copyright: 2019-2021
 * @FileName: RectangleOverlap.java
 * @Author: PJL
 * @Date: 2020/7/14 18:21
 * @Description: 矩形重叠面积
 */
public class RectangleOverlap {

    /**
     * 计算重叠区域面积
     *
     * @param rect1
     * @param rect2
     * @return
     */
    public double calculateOverlapArea(Rectangle rect1, Rectangle rect2) {
        if (rect1 == null || rect2 == null) {
            return -1;
        }
        double p1_x = rect1.getX(), p1_y = rect1.getY();
        double p2_x = p1_x + rect1.getLength(), p2_y = p1_y + rect1.getWidth();
        double p3_x = rect2.getX(), p3_y = rect2.getY();
        double p4_x = p3_x + rect2.getLength(), p4_y = p3_y + rect2.getWidth();

        if (p1_x > p4_x || p2_x < p3_x || p1_y > p4_y || p2_y < p3_y) {
            return 0;
        }
        double Len = Math.min(p2_x, p4_x) - Math.max(p1_x, p3_x);
        double Wid = Math.min(p2_y, p4_y) - Math.max(p1_y, p3_y);
        return Len * Wid;
    }

    public static void main(String[] args) {
        Rectangle rect1 = new Rectangle(0, 1, 3, 2);
        Rectangle rect2 = new Rectangle(2, 0, 2, 2);
        RectangleOverlap overlap = new RectangleOverlap();
        System.out.println(overlap.calculateOverlapArea(rect1, rect2));
    }
}

 

聚合计算工具类

package com.boonya.beans.util;

import com.alibaba.fastjson.JSONArray;
import com.boonya.beans.Constants;
import com.boonya.beans.gis.Rectangle;
import com.boonya.beans.gis.RectangleOverlap;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;

import java.util.List;
import java.util.Map;

/**
 * @Copyright: 2019-2021
 * @FileName: LogicUtil.java
 * @Author: PJL
 * @Date: 2020/6/29 15:34
 * @Description: 逻辑处理工具类
 */
@Slf4j
public class LogicUtil {

    /**
     * 获取四至范围数组
     *
     * @param extentArray
     * @return
     */
    public static Double[] getExtent(JSONArray extentArray) {
        int count = extentArray.size();
        Double[] extent = new Double[count];
        for (int i = 0; i < count; i++) {
            extent[i] = extentArray.getDouble(i);
        }
        return extent;
    }

    /**
     * 解析组织机构数组
     *
     * @param list
     * @return
     */
    public static String[] getOrgIds(List<Map<String, Object>> list) {
        if (ObjectUtils.isEmpty(list)) {
            return new String[]{};
        }
        String[] orgIds = new String[list.size()];
        int index = 0;
        for (Map<String, Object> map : list) {
            orgIds[index] = null == map.get("I_ORGID") ? map.get("i_orgid").toString() : map.get("I_ORGID").toString();
            index++;
        }
        return orgIds;
    }

    /**
     * 组织机构过滤条件
     *
     * @param orgIds
     * @return
     */
    public static String getOrgFilterString(String[] orgIds) {
        if (ObjectUtils.isEmpty(orgIds)) {
            return "-1";
        }
        StringBuffer sb = new StringBuffer();
        for (int i = 0, j = orgIds.length; i < j; i++) {
            if (i == 0) {
                sb.append(orgIds[i]);
            } else {
                sb.append(",").append(orgIds[i]);
            }
        }
        return sb.toString();
    }

    /**
     * 根据地图缩放层级获取组织机构编号长度条件位数
     *
     * @param level
     * @param isAll
     * @return
     */
    public static int getOrgCodeLengthByLevel(Integer level, boolean isAll) {
        int result = 0;
        switch (level) {
            /****************一级*****************/

            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
                if (isAll) {
                    /****************全国*****************/
                    result = 1;
                } else {
                    result = 4;
                }
                break;
            /****************二级*****************/
            case 7:
            case 8:
                result = 4 * 2;
                break;
            /****************三级级*****************/
            case 9:
            case 10:
                result = 4 * 3;
                break;
            /****************四级*****************/
            case 11:
            case 12:
                result = 4 * 4;
                break;
            /****************五级*****************/
            case 13:
            case 14:
                result = 4 * 5;
                break;
            /****************默认*****************/
            default:
                result = 4 * 5;
                break;
        }
        return result;
    }

    /**
     * 四至范围扩大计算
     *
     * @param zoom
     * @param extent
     * @return
     */
    public static Double[] extentBetter(Integer zoom, Double[] extent) {
        // 15级之前四至范围扩大百分之20(解决四至范围没有组织机构中心点问题)
        if (zoom.intValue() <= Constants.MAP_AGGREGATION_MAX_ZOOM_NUMBER) {
            double factor = 1.2;
            extent[0] /= factor;// 左下角点X缩小
            extent[1] /= factor;// 左下角点Y缩小
            extent[2] *= factor;// 右上角点X扩大
            extent[3] *= factor;// 右上角点Y扩大
        }
        return extent;
    }

    /**
     * 获取重叠部分面积值
     *
     * @param screenExtent
     * @param orgExtent
     * @return
     */
    public static double getRectangleArea(Double[] screenExtent, Double[] orgExtent) {
        double screenLength = Math.abs(screenExtent[2] - screenExtent[0]);
        double screenWidth = Math.abs(screenExtent[3] - screenExtent[1]);
        double orgLength = Math.abs(orgExtent[2] - orgExtent[0]);
        double orgWidth = Math.abs(orgExtent[3] - orgExtent[1]);
        Rectangle rectangle = new Rectangle(screenExtent[0], screenExtent[1], screenLength, screenWidth);
        Rectangle rectangle2 = new Rectangle(orgExtent[0], orgExtent[1], orgLength, orgWidth);
        RectangleOverlap overlap = new RectangleOverlap();
        return overlap.calculateOverlapArea(rectangle, rectangle2);
    }

    /**
     * 矩形相交屏幕占比计算(百分数值)
     *
     * @param screenExtent
     * @param orgExtent
     * @return
     */
    public static long getShadowRateOfRectangle(Double[] screenExtent, Double[] orgExtent) {
        double screenLength = Math.abs(screenExtent[2] - screenExtent[0]);
        double screenWidth = Math.abs(screenExtent[3] - screenExtent[1]);
        double areaScreen = screenLength * screenWidth;
        double overlayArea = getRectangleArea(screenExtent, orgExtent);
        long percentage = Math.round(overlayArea / areaScreen * 100);
        log.info(">>>>LogicUtil overlayArea={}  percentage = {}", overlayArea, percentage);
        return percentage;
    }

    /**
     * 判断两个矩形是否有重叠部分
     *
     * @param screenExtent
     * @param orgExtent
     * @return
     */
    public static boolean isIntersected(Double[] screenExtent, Double[] orgExtent) {
        boolean flag = false;
        double overlayArea = getRectangleArea(screenExtent, orgExtent);
        if (overlayArea > 0) {
            flag = true;
        }
        log.info(">>>>LogicUtil overlayArea={} isIntersected = {}", overlayArea, flag);
        return flag;
    }
}

政区聚合递归算法：

  /**
     * 根据四至计算地图显示数据方式【聚合/散点】==返回组织机构标识
     *
     * @param org
     * @param screenExtent
     * @param orgMap       k-v = 组织机构ID-组织机构编码:是否聚合(true|false)
     * @return
     */
    public Map<String, Boolean> calculateOrgAggregationData(Org org, Double[] screenExtent, Map<String, Boolean> orgMap) {
        Double[] orgExtent = org.getExtent();
        // 第一步: 屏幕四至求交组织机构四至
        boolean intersected = LogicUtil.isIntersected(screenExtent, orgExtent);
        if (intersected) {
            // 计算当前组织机构占比
            long rate = LogicUtil.getShadowRateOfRectangle(screenExtent, orgExtent);
            String key = new StringBuffer(org.getId()).append("-").append(org.getCode()).toString();
            if (rate < Constants.MAP_AGGREGATION_SCREEN_RATE) {
                orgMap.put(key, true);// 设置是否聚合
            } else {
                try {
                    List<Map<String, Object>> list = this.getDirectChildrenOrgListById(org.getId());
                    if (ObjectUtils.isNotEmpty(list)) {
                        for (Map<String, Object> childOrg : list) {
                            Org tempOrg = this.getOrgPositionByMap(childOrg);
                            // 递归获取下级单位占比值
                            calculateOrgAggregationData(tempOrg, screenExtent, orgMap);
                        }
                    } else {
                        // 没有下级单位 但面积大于MAP_AGGREGATION_SCREEN_RATE
                        orgMap.put(key, false);// 设置是否聚合
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return orgMap;
    }

 Constants.MAP_AGGREGATION_SCREEN_RATE =20

聚合效果图

注：本文介绍算法适用于组织机构有中心点和四至范围的情况。

boonya
关注
专栏目录
中国地理位置四至点及计算方法
weixin_33998125的博客
05-26 3952
为什么80%的码农都做不了架构师？>>> ...
一种简单的地图聚合算法
蓝冷然的博客
01-04 1万+
百度地图的聚合算法 这段百度算法的描述来自博客：https://blog.csdn.net/javine/article/details/51195014 总结如下： 百度地图把整个地球是按照一个平面来展开，把整个地球按照平面来展开之后，我们就能算出这个地球平面的宽度，也就是世界宽度。 计算公式是这样的：256*（zoom^2） == worldWidth 其中zoom就是地图的层级，我们缩放地图...
计算和标注宗地四至点坐标的操作步骤
05-02
在ARCGIS10.2中计算和标注宗地四至点坐标的操作步骤。
[技巧]Arcgis之图斑四至范围批量计算
沙漠之花的博客
03-01 1890
在GIS中通过字段计算器中计算几何即可计算XY坐标，我们也可以根据这个功能将要素转折点再计算坐标，进而提取四至坐标；中坐标一般有两种表达形式，一种是地理坐标（也就是常说的经纬度，通常单位为度或度分秒格式），另一种是投影坐标（俗称平面直角坐标，通常单位为米）。如下图画出来的框（范围标记不是很准） ，图斑的x最大和x最小，y最大，y最小值则为四至范围值，通俗的讲就是图斑的。介于以上要求：软件实现批量计算，支持多个图层批量计算四至范围，并计算矩形范围坐标；
【GIS技术】Shp矢量图斑数据的四至点坐标或四至坐标计算
最新发布
qq_39719713的博客
06-18 987
经常有从事gis相关、地信相关行业的朋友或者是需要对图斑矢量进行的计算的时候，按照各类搜索引擎或者是教学文章中的教学步骤求出来的四至坐标是特别是比如林业图斑求四至点、农田四至点等等。错的原因在于很多文章中教学的四至坐标实际上指的是图斑矢量最东最西的点做一条垂线与图斑矢量最南最北的点做一条水平线相交而成的矩形的四个顶点坐标。这样的矩形我们称之为，，这四个点称之为图斑矢量最小外接矩形的四至值，也叫范围值。而实际上我们要求的是图斑上最东/南/西/北的那个点的坐标值。这四个点才称之为是俗称的四至点。
百度地图点聚合MarkerClusterer，性能优化
weixin_30261095的博客
12-29 1428
参考文献：http://www.cnblogs.com/lightnull/p/6184867.html 百度的点聚合算法 是基于方格和距离的聚合算法，即开始的时候地图上没有任何已知的聚合点，然后遍历所有的点，去计算点的外包正方形（由gridSize指定），若此点的外包正方形与现有的聚合点的外包正方形不相交，则新建聚合点，若相交就把该点加到该聚合点，效果如下图，为了便于查看，我们特地把外包...
深度视频质量评估器：时空视敏度的卷积神经聚合网络
深度视频质量评估器：从时空视敏度到A卷积神经聚合网络Woojae Kim1、Jongyoo Kim2、SewoongAhn1、Jinwoo Kim1和Sanghoon Lee1（）1延世大学电机电子工学系{wooyoa，anse3832，jw09191，slee}@ yonsei.ac.kr2微软研究...
基于凸性形状先验的弹性测地线方法
6900基于凸性形状先验的弹性测地线方法大陈山东省人工智能研究院，齐鲁工业大学（山东省科学院），中国dachen.cn邮件hotmail.com让-玛丽·米雷博洛朗·D 科恩巴黎第九大学，PSL研究大学，CNRS，UMR7534，CEREMADE，...
基于深度学习的几何失真校正方法
我们提出的方法采用卷积神经网络（CNN）训练使用一个大的合成失真数据集预测失真图像和校正图像之间的位移场。模型拟合方法使用CNN输出来估计失真参数，实现更准确的预测。使用高效、高质量的重采样方法基于预测流量...
学习语义形状部分分割的神经框架：PartGlot
116505输出段输入（超级分段）PartGlot：从语言参考游戏中学习形状部分分割朱伊古1伊恩黄2帕诺斯Achlioptas2，3列奥尼达Guibas2 Minhyuk Sung1 KAIST2斯坦福大学3Snap Inc.0 1注意力地图后排座椅支腿臂（a）用于机器...
【转】GIS空间分析的功能和广泛应用
04-02 1855
GIS空间分析的功能和广泛应用 一、GIS空间分析的功能 空间分析分为： 1、空间图形数据的拓扑运算； 2、非空间属性数据运算； 3、空间和非空间数据的联合运算。 空间分析赖以进行的基础是仰仗于地理空间数据库，其运用的手段包括各种几何的逻辑运算、数理统计分析，代数运算等数学手段，最终的目的是解决人们所涉及到地理空间的实际问题，提取和传输地理空间信...
地图点聚合
12-24
之前在项目中需要用到百度地图的点聚合，看了百度提供的demo之后，稍微读了一些源码就能达到需求了，所以并未深入解读源码。 最近有空就把百度实现点聚合的源码从里到外仔细研究了一遍受益良多，在此分享一下。
Bmap-markerCluster:百度地图10W数量级的打点聚合，解决官方聚合的性能问题
05-17
MarkerCluster 百度地图10W数量级的打点聚合，解决官方聚合的性能问题。正在测试优化中，可以在dev分支中尝试效果。 对百度官方聚合优化的点 我想这部分应该才是大家更关心的点，因此在此分享下优化的经验。 1、聚合计算完成后，再进行dom操作 百度原生聚合是计算一次，进行一个dom操作，然后进行下一次计算。不得不吐槽百度地图js是实习生还是后端人员写的，还看过其他开源库也有类似的问题。 2、不使用Map.getDistence()来计算两点距离，而是使用平面坐标系（墨卡托坐标系）计算两点距离 在聚合算法中，需要频繁使用getDistence（）来判断最近的聚合点，此方法性能损耗很大，10w个点聚合计算，需要3s以上的时间。而预先转换为平面坐标系（墨卡托坐标）后，可以使时间减少至360ms（一般200多ms）左右. 3、使用webAssembly 使用webAssembly可以提高
ArcGIS小知识（二）——计算四至点坐标（arcgis）
热门推荐
liukunrs的博客
05-06 3万+
四至点坐标，即左上经、左上纬、右下经、右下纬(在地理坐标系下,计算的是经纬度,否则是6位数的那种投影坐标)
基于瓦片划分的地图点聚合算法
TJLCY的博客
12-30 706
实现了一种基于瓦片划分的地图点位聚合算法
地图聚合算法
蓝天白云
02-14 3742
一、为什么需要点聚合 在地图上查询结果通常以标记点的形式展现，但是如果标记点较多，不仅会大大增加客户端的渲染时间，让客户端变得很卡，而且会让人产生密集恐惧症（图1）。为了解决这一问题，我们需要一种手段能在用户有限的可视区域范围内，利用最小的区域展示出最全面的信息，而又不产生重叠覆盖。 图1 二、已尝试的方案---kmeans 直觉上用聚类算法能较好达成我们...
地图标记聚合算法
weixin_33806509的博客
04-10 1241
需要实现一个地图图标聚合算法, 最终功能类似 安居客 在地图搜索房源的功能. 当地图缩放级别较大时, 仅用一个地图标记显示该区域总数; 当地图缩小至一定级别时, 每条信息才可以显示为单独的图标. 自己拟了一套算法, 基本思想是, 以网格递归分割全部数据点, 直到网格大小达到阈值, 或者每个网格内都仅存在至多一个数据点. 然后根据递归层次 ...
【约球online】小程序构建系列教程第三话——地图点聚合功能实现
HouGISer的博客
10-11 3004
文章目录前言需求聚合算法具体实现调用时机 前言 用过微信小程序的map组件开发地图的同学，应该知道mapcontext这个对象的api相当少，功能远不如百度、腾讯、高德地图的JavaScript API。如果要实现聚合、热力图等，都必须自己动手实现。 地图开发最常见的一个需求就是展示点要素，如果需要展示大量的点要素，如果全部展示，不仅渲染上存在很大的开销，而且也会存在图标压盖等问题，影响体验，因此就需要有点聚合的功能，并且随地图缩放来自动重算。 这篇教程就交大家如何实现一个通用的点聚合功能，并在文末附上源码
全国计算机四级网络工程师历年真题与解析
"全国计算机四级网络工程师真题涵盖了2008年4月至2011年9月的考试内容，主要针对网络工程师这一级别的考试，包括选择题、理论知识等多个方面，旨在测试考生对网络架构、协议、设备性能、网络安全及IP地址规划等核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值