From 5a8786a5d76d406315aff23a050caa8d360f6061 Mon Sep 17 00:00:00 2001
From: lizijie <lzjiiie@163.com>
Date: Fri, 08 Apr 2022 08:48:28 +0800
Subject: [PATCH] 热力图工具类

---
 screen-common/src/main/java/com/moral/util/DoubleUtils.java               |  198 ++++++++++++++++++++++++
 screen-common/src/main/java/com/moral/util/OtgUtils.java                  |  212 ++++++++++++++++++++++++++
 screen-common/src/main/java/com/moral/util/LongitudeAndLatitudeUtils.java |   65 ++++++++
 3 files changed, 475 insertions(+), 0 deletions(-)

diff --git a/screen-common/src/main/java/com/moral/util/DoubleUtils.java b/screen-common/src/main/java/com/moral/util/DoubleUtils.java
new file mode 100644
index 0000000..5d23f05
--- /dev/null
+++ b/screen-common/src/main/java/com/moral/util/DoubleUtils.java
@@ -0,0 +1,198 @@
+package com.moral.util;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+
+/**
+ * @program: screen
+ * @description: double������������
+ * @author: lizijie
+ * @create: 2022-03-22 17:30
+ **/
+public class DoubleUtils implements Serializable {
+
+    private static final long serialVersionUID = -3345205828566485102L;
+
+// ������������������������
+
+    private static final Integer DEF_DIV_SCALE = 2;
+
+    /**
+
+     * ������������������������������
+
+     * @param value1 ���������
+
+     * @param value2 ������
+
+     * @return ������������������
+
+     */
+
+    public static Double add(Number value1, Number value2) {
+
+        BigDecimal b1 = new BigDecimal(Double.toString(value1.doubleValue()));
+
+        BigDecimal b2 = new BigDecimal(Double.toString(value2.doubleValue()));
+
+        return b1.add(b2).doubleValue();
+
+    }
+
+    /**
+
+     * ������������������������������
+
+     *
+
+     * @param value1
+
+     * ���������
+
+     * @param value2
+
+     * ������
+
+     * @return ������������������
+
+     */
+
+    public static double sub(Number value1, Number value2) {
+
+        BigDecimal b1 = new BigDecimal(Double.toString(value1.doubleValue()));
+
+        BigDecimal b2 = new BigDecimal(Double.toString(value2.doubleValue()));
+
+        return b1.subtract(b2).doubleValue();
+
+    }
+
+    /**
+
+     * ������������������������������
+
+     *
+
+     * @param value1
+
+     * ���������
+
+     * @param value2
+
+     * ������
+
+     * @return ������������������
+
+     */
+
+    public static Double mul(Number value1, Number value2) {
+
+        BigDecimal b1 = new BigDecimal(Double.toString(value1.doubleValue()));
+
+        BigDecimal b2 = new BigDecimal(Double.toString(value2.doubleValue()));
+
+        return b1.multiply(b2).doubleValue();
+
+    }
+
+    /**
+
+     * ������(������)��������������������������������������������������������� ������������������������10������������������������������������
+
+     *
+
+     * @param dividend
+
+     * ���������
+
+     * @param divisor
+
+     * ������
+
+     * @return ������������������
+
+     */
+
+    public static Double div(Double dividend, Double divisor) {
+
+        return div(dividend, divisor, DEF_DIV_SCALE);
+
+    }
+
+    /**
+
+     * ������(������)������������������������ ������������������������������������scale���������������������������������������������������
+
+     *
+
+     * @param dividend
+
+     * ���������
+
+     * @param divisor
+
+     * ������
+
+     * @param scale
+
+     * ���������������������������������������������������
+
+     * @return ������������������
+
+     */
+
+    public static Double div(Double dividend, Double divisor, Integer scale) {
+
+        if (scale < 0) {
+
+            throw new IllegalArgumentException(
+
+                    "The scale must be a positive integer or zero");
+
+        }
+
+        BigDecimal b1 = new BigDecimal(Double.toString(dividend));
+
+        BigDecimal b2 = new BigDecimal(Double.toString(divisor));
+
+        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
+
+    }
+
+    /**
+
+     * ���������������������������������������������
+
+     *
+
+     * @param value
+
+     * ���������������������������
+
+     * @param scale
+
+     * ������������������������
+
+     * @return ������������������������
+
+     */
+
+    public static Double round(Double value, Integer scale) {
+
+        if (scale < 0) {
+
+            throw new IllegalArgumentException(
+
+                    "The scale must be a positive integer or zero");
+
+        }
+
+        BigDecimal b = new BigDecimal(Double.toString(value));
+
+        BigDecimal one = new BigDecimal("1");
+
+        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
+
+    }
+
+}
diff --git a/screen-common/src/main/java/com/moral/util/LongitudeAndLatitudeUtils.java b/screen-common/src/main/java/com/moral/util/LongitudeAndLatitudeUtils.java
new file mode 100644
index 0000000..2695e13
--- /dev/null
+++ b/screen-common/src/main/java/com/moral/util/LongitudeAndLatitudeUtils.java
@@ -0,0 +1,65 @@
+package com.moral.util;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+/**
+ * @program: screen
+ * @description: ������������������������������
+ * @author: lizijie
+ * @create: 2022-03-22 17:03
+ **/
+public class LongitudeAndLatitudeUtils {
+
+    private static final double EARTH_RADIUS = 6378.137;
+
+    private static double rad(double d){
+        return d * Math.PI / 180.0;
+    }
+
+    public static double getmeter(double long1, double lat1, double long2, double lat2) {
+        double a, b, d, sa2, sb2;
+        lat1 = rad(lat1);
+        lat2 = rad(lat2);
+        a = lat1 - lat2;
+        b = rad(long1 - long2);
+
+        sa2 = Math.sin(a / 2.0);
+        sb2 = Math.sin(b / 2.0);
+        d = 2   * EARTH_RADIUS
+                * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(lat1)
+                * Math.cos(lat2) * sb2 * sb2));
+        d= d * 1000;
+        BigDecimal bg = new BigDecimal(d).setScale(2, RoundingMode.UP);
+
+        return bg.doubleValue();
+
+
+        // return  d;
+
+    }
+
+    public static String getStringmeter(double long1, double lat1, double long2, double lat2) {
+        double a, b, d, sa2, sb2;
+        lat1 = rad(lat1);
+        lat2 = rad(lat2);
+        a = lat1 - lat2;
+        b = rad(long1 - long2);
+
+        sa2 = Math.sin(a / 2.0);
+        sb2 = Math.sin(b / 2.0);
+        d = 2   * EARTH_RADIUS
+                * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(lat1)
+                * Math.cos(lat2) * sb2 * sb2));
+        d= d * 1000;
+        BigDecimal bg = new BigDecimal(d).setScale(2, RoundingMode.UP);
+
+        return String.valueOf(bg.doubleValue());
+
+
+        // return  d;
+
+    }
+
+
+}
diff --git a/screen-common/src/main/java/com/moral/util/OtgUtils.java b/screen-common/src/main/java/com/moral/util/OtgUtils.java
new file mode 100644
index 0000000..7b7e56d
--- /dev/null
+++ b/screen-common/src/main/java/com/moral/util/OtgUtils.java
@@ -0,0 +1,212 @@
+package com.moral.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @program: screen
+ * @description: ���������������������������������������
+ * @author: lizijie
+ * @create: 2022-03-22 11:57
+ **/
+public class OtgUtils {
+
+    /**
+     * ��������� ������������������������������ 4(n)���������8(n*2)��������� ���8(n*2)���������(���������������������������)���������������������������(������������������������������)���������������������������������
+     * ���������������������������
+     *
+     * @param px1
+     * @param py1
+     * @param px2
+     * @param py2
+     * @param px3
+     * @param py3
+     * @param px4
+     * @param py4
+     * @return
+     */
+    public boolean isIntersect(double px1, double py1, double px2, double py2, double px3, double py3, double px4,
+                               double py4) {
+        boolean flag = false;
+        double d = (px2 - px1) * (py4 - py3) - (py2 - py1) * (px4 - px3);
+        if (d != 0) {
+            double r = ((py1 - py3) * (px4 - px3) - (px1 - px3) * (py4 - py3)) / d;
+            double s = ((py1 - py3) * (px2 - px1) - (px1 - px3) * (py2 - py1)) / d;
+            if ((r >= 0) && (r <= 1) && (s >= 0) && (s <= 1)) {
+                flag = true;
+            }
+        }
+        return flag;
+    }
+
+    /**
+     * ������������������������������������
+     *
+     * @param px0
+     *            ������������������������
+     * @param py0
+     *            ������������������������
+     * @param px1
+     *            ������������������(������)������������
+     * @param py1
+     *            ������������������(������)������������
+     * @param px2
+     *            ������������������(������)������������
+     * @param py2
+     *            ������������������(������)������������
+     * @return
+     */
+    public boolean isPointOnLine(double px0, double py0, double px1, double py1, double px2, double py2) {
+        boolean flag = false;
+        double ESP = 1e-9;// ������������������
+        if ((Math.abs(Multiply(px0, py0, px1, py1, px2, py2)) < ESP) && ((px0 - px1) * (px0 - px2) <= 0)
+                && ((py0 - py1) * (py0 - py2) <= 0)) {
+            flag = true;
+        }
+        return flag;
+    }
+    public double Multiply(double px0, double py0, double px1, double py1, double px2, double py2) {
+        return ((px1 - px0) * (py2 - py0) - (px2 - px0) * (py1 - py0));
+    }
+
+    /**
+     * ������������������������������������(������������������)
+     *
+     * @param px
+     *            ������������������������
+     * @param py
+     *            ������������������������
+     * @param polygonXA
+     *            ������������������������������
+     * @param polygonYA
+     *            ������������������������������
+     * @return
+     */
+    public boolean inPointInPolygon(double px, double py, ArrayList<Double> polygonXA, ArrayList<Double> polygonYA) {
+        boolean isInside = false;
+        double ESP = 1e-9;
+        int count = 0;
+        double linePoint1x;
+        double linePoint1y;
+        double linePoint2x = 180;
+        double linePoint2y;
+
+        linePoint1x = px;
+        linePoint1y = py;
+        linePoint2y = py;
+
+        for (int i = 0; i < polygonXA.size() - 1; i++) {
+            double cx1 = polygonXA.get(i);
+            double cy1 = polygonYA.get(i);
+            double cx2 = polygonXA.get(i + 1);
+            double cy2 = polygonYA.get(i + 1);
+            // ������������������������������������
+            if (isPointOnLine(px, py, cx1, cy1, cx2, cy2)) {
+                return true;
+            }
+            // ������������������������������(���������)���������������������������������������������������������������
+            if (Math.abs(cy2 - cy1) < ESP) {
+                continue;
+            }
+            // ������������������������������������������������������������������
+            if (isPointOnLine(cx1, cy1, linePoint1x, linePoint1y, linePoint2x, linePoint2y)) {
+                // ���������������������������������,������������������������(������������)
+                if (cy1 > cy2)
+                    count++;
+            }
+            // ������������������������������������������������������������������
+            else if (isPointOnLine(cx2, cy2, linePoint1x, linePoint1y, linePoint2x, linePoint2y)) {
+                // ���������������������������������,������������(���������������)���������90(������������)
+                if (cy2 > cy1)
+                    count++;
+            }
+            // ������������������������������������������������������������������������������������
+            else if (isIntersect(cx1, cy1, cx2, cy2, linePoint1x, linePoint1y, linePoint2x, linePoint2y)) {
+                count++;
+            }
+        }
+        if (count % 2 == 1) {
+            isInside = true;
+        }
+        return isInside;
+    }
+
+    /**
+     * ������������������������������������������������������������4������������������������������������������5���������6���������������������������
+     */
+    public static Boolean isPointInPolygon(List<Map<String,Double>> areas, double px,double py){
+
+        /**
+         * ������x,������y
+         * ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������x������������y������������������������������������������������������������������������������
+         * ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������
+         */
+        /*Map<String, Double> map1 = new HashMap<String,Double>();//������
+        map1.put("px", 113.897051);
+        map1.put("py",22.301719);
+        Map<String, Double> map2 = new HashMap<String,Double>();//������
+        map2.put("px", 113.897051);
+        map2.put("py", 22.32022);
+        Map<String, Double> map3 = new HashMap<String,Double>();//������
+        map3.put("px", 113.94599);
+        map3.put("py", 22.32022);
+        Map<String, Double> map4 = new HashMap<String,Double>();//������
+        map4.put("px", 113.94599);
+        map4.put("py", 22.301719);*/
+//      Map<String, Double> map5 = new HashMap<String,Double>();//������������������������
+//      map5.put("px", 113.9273643);
+//      map5.put("py", 22.3129196);
+
+        //���������������!!
+        /*List<Map<String,Double>> areas=new ArrayList<Map<String,Double>>();
+        areas.add(map1);
+        areas.add(map2);
+        areas.add(map3);
+        areas.add(map4);*/
+//      areas.add(map5);
+
+        ArrayList<Double> polygonXA = new ArrayList<Double>();
+        ArrayList<Double> polygonYA = new ArrayList<Double>();
+        for(int i=0;i<areas.size();i++){
+            Map<String, Double> map = areas.get(i);
+            polygonXA.add(map.get("px"));
+            polygonYA.add(map.get("py"));
+        }
+
+        OtgUtils otg = new OtgUtils();
+
+        //true���������������false���������������
+        Boolean flag= otg.inPointInPolygon(px, py, polygonXA, polygonYA);
+
+        //==������������������������������������������������������������flag���������������������������������������������������������������������������������======================
+        /*StringBuffer buffer=new StringBuffer();
+        buffer.append("���������").append("(").append(px).append(",").append(py).append(")").append("\n");
+        buffer.append(flag?"���":"������").append("\t").append("���\n");
+        for(int i=0;i<areas.size();i++){
+            Map<String, Double> map = areas.get(i);
+            Double x = map.get("px");
+            Double y = map.get("py");
+
+            StringBuffer bufferr=new StringBuffer();
+            String string = bufferr.append("(").append(x).append(",").append(y).append(")").toString();
+
+            buffer.append(string).append("; ");
+        }
+        System.out.println("������������"+flag);
+        buffer.append("\n"+areas.size()).append("���������������").append(areas.size()).append("���������");
+        System.out.println(buffer.toString());*/
+        //==���������������������������������������������������������������������������======================
+
+        return flag;
+    }
+
+    //������������
+    public static void main(String[] args) {
+
+        //isPointInPolygon(113.9079236,22.3075597);
+
+    }
+
+}

--
Gitblit v1.8.0