From e89f1f719d8079aff609db26ffd30fd46c7e9b8e Mon Sep 17 00:00:00 2001
From: cjl <276999030@qq.com>
Date: Mon, 17 Jul 2023 08:57:23 +0800
Subject: [PATCH] chore: 提交测试
---
screen-api/src/main/java/com/moral/api/controller/UAVController.java | 427 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 421 insertions(+), 6 deletions(-)
diff --git a/screen-api/src/main/java/com/moral/api/controller/UAVController.java b/screen-api/src/main/java/com/moral/api/controller/UAVController.java
index 29c41ef..9d9582b 100644
--- a/screen-api/src/main/java/com/moral/api/controller/UAVController.java
+++ b/screen-api/src/main/java/com/moral/api/controller/UAVController.java
@@ -1,9 +1,14 @@
package com.moral.api.controller;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.moral.api.entity.HistorySecondUav;
import com.moral.api.mapper.HistorySecondUavMapper;
+import com.moral.api.pojo.dto.uav.UAVGteForDTO;
import com.moral.api.pojo.dto.uav.UAVQueryTimeSlotDTO;
+import com.moral.api.pojo.dto.uav.UAVResultDTO;
import com.moral.api.pojo.form.uav.UAVQueryTimeSlotForm;
import com.moral.api.pojo.vo.uav.HistorySecondUavVOs;
import com.moral.api.pojo.vo.uav.UAVQueryDateVO;
@@ -20,6 +25,9 @@
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.text.DecimalFormat;
import java.util.*;
/**
@@ -61,12 +69,183 @@
}
@RequestMapping("test")
- public ResultMessage test(String batch){
- QueryWrapper<HistorySecondUav> wrapper = new QueryWrapper();
- wrapper.select("value");
- wrapper.eq("batch", "2021-07-08 01:00:00");
- List<HistorySecondUav> datas = historySecondUavMapper.selectList(wrapper);
- return new ResultMessage(ResponseCodeEnum.SUCCESS.getCode(), ResponseCodeEnum.SUCCESS.getMsg(),datas);
+ public ResultMessage test(){
+ //������
+ ArrayList<Double> flyLatList = new ArrayList<>();
+ //������
+ ArrayList<Double> flyLonList = new ArrayList<>();
+ HashMap<String, Object> map = new HashMap<>();
+ String mac ="p5dnd7a0243592";
+ String time1 ="2023-05-14 10:40:00";
+ String time2 ="2023-05-14 11:10:00";
+ map.put("mac",mac);
+ map.put("time1",time1);
+ map.put("time2",time2);
+// List<UAVResultDTO> uavResultDTOS = historySecondUavMapper.reList(map);
+ QueryWrapper<HistorySecondUav> queryWrapper = new QueryWrapper<>();
+ queryWrapper.select("value");
+ queryWrapper.eq("mac",mac);
+ queryWrapper.between("time",time1,time2);
+ List<HistorySecondUav> historySecondUavs = historySecondUavMapper.selectList(queryWrapper);
+ for (HistorySecondUav historySecondUav : historySecondUavs) {
+ String value = historySecondUav.getValue();
+ Map map1 = JSON.parseObject(value, Map.class);
+ flyLatList.add(Double.parseDouble(map1.get("flylat").toString()));
+ flyLonList.add(Double.parseDouble(map1.get("flylon").toString()));
+
+ }
+ Double maxLat = Collections.max(flyLatList);
+ Double maxLon = Collections.max(flyLonList);
+ Double minLat = Collections.min(flyLatList);
+ Double minLon = Collections.min(flyLonList);
+
+ //������������������
+ String leftTop = minLat +";"+ maxLon;
+ //������
+ String rightTop = maxLat +";"+ maxLon;
+ //������
+ String leftBottom = minLat +";" + minLon;
+ //������
+ String rightBottom = maxLat +";" + minLon;
+ //���������������������
+ double distance1 = getDistance(maxLon, minLat, maxLon, maxLat);
+ //���������������������
+ double distance2 = getDistance(maxLon, minLat, minLon, minLat);
+ ArrayList<UAVGteForDTO> list = new ArrayList<>();
+ //������������
+
+ String [] lefts =new String[]{maxLon.toString(),minLat.toString()};
+ //������2
+ String[] youshang = calLocationByDistanceAndLocationAndDirection(90, minLon, maxLat, 50);
+ //������2
+ String[] youxia = calLocationByDistanceAndLocationAndDirection(180, Double.parseDouble(youshang[0]), Double.parseDouble(youshang[1]), 50);
+ //������2
+ String[] zuoxia = calLocationByDistanceAndLocationAndDirection(180, minLon, maxLat, 50);
+
+ for (int i = 0; i <distance1 ; i+=60) {
+ UAVGteForDTO dto1 = new UAVGteForDTO();
+ String[] strings2 = calLocationByDistanceAndLocationAndDirection(90, minLon, maxLat, i);
+ String[] strings3 = calLocationByDistanceAndLocationAndDirection(90, Double.parseDouble(youshang[0].toString()), Double.parseDouble(youshang[1].toString()), i);
+ String[] strings4 = calLocationByDistanceAndLocationAndDirection(90, Double.parseDouble(youxia[0].toString()), Double.parseDouble(youxia[1].toString()), i);
+ String[] strings5 = calLocationByDistanceAndLocationAndDirection(90, Double.parseDouble(zuoxia[0].toString()), Double.parseDouble(zuoxia[1].toString()), i);
+ dto1.setLeftTop(strings2);
+ dto1.setRightTop(strings3);
+ dto1.setRightBottom(strings4);
+ dto1.setLeftBottom(strings5);
+ list.add(dto1);
+ for (int j = 0; j < distance2; j+=60) {
+ UAVGteForDTO dto2 = new UAVGteForDTO();
+ String[] strings6 = calLocationByDistanceAndLocationAndDirection(180, Double.parseDouble(strings2[0].toString()), Double.parseDouble(strings2[1].toString()), j);
+ String[] strings7 = calLocationByDistanceAndLocationAndDirection(180, Double.parseDouble(strings3[0].toString()), Double.parseDouble(strings3[1].toString()), j);
+ String[] strings8 = calLocationByDistanceAndLocationAndDirection(180, Double.parseDouble(strings4[0].toString()), Double.parseDouble(strings4[1].toString()), j);
+ String[] strings9 = calLocationByDistanceAndLocationAndDirection(180, Double.parseDouble(strings5[0].toString()), Double.parseDouble(strings5[1].toString()), j);
+ dto2.setLeftTop(strings6);
+ dto2.setRightTop(strings7);
+ dto2.setRightBottom(strings8);
+ dto2.setLeftBottom(strings9);
+ if (j!=0){
+ list.add(dto2);
+ }
+ }
+ }
+ ArrayList<UAVResultDTO> uavResultDTOS1 = new ArrayList<>();
+ for (UAVGteForDTO uavGteForDTO : list) {
+ ArrayList<String[]> doubleArrayList = new ArrayList<>();
+ doubleArrayList.add(uavGteForDTO.getLeftTop());
+ doubleArrayList.add(uavGteForDTO.getLeftBottom());
+ doubleArrayList.add(uavGteForDTO.getRightTop());
+ doubleArrayList.add(uavGteForDTO.getRightBottom());
+ UAVResultDTO result = getResult(doubleArrayList);
+ uavResultDTOS1.add(result);
+ }
+ if (uavResultDTOS1!=null){
+ return new ResultMessage(ResponseCodeEnum.SUCCESS.getCode(), ResponseCodeEnum.SUCCESS.getMsg(),uavResultDTOS1);
+
+ }
+
+// ArrayList<List<String>> lists = new ArrayList<>();
+ HashMap<String,List<String>> rsMap = new HashMap<>();
+// HashMap<String,List<Map<String,Object>>> rsMap1 = new HashMap<>();
+ for (UAVGteForDTO uavGteForDTO : list) {
+ ArrayList<String> list1 = new ArrayList<>();
+ ArrayList<String[]> doubleArrayList = new ArrayList<>();
+ doubleArrayList.add(uavGteForDTO.getLeftTop());
+ doubleArrayList.add(uavGteForDTO.getLeftBottom());
+ doubleArrayList.add(uavGteForDTO.getRightTop());
+ doubleArrayList.add(uavGteForDTO.getRightBottom());
+ //������������������
+ for (HistorySecondUav historySecondUav : historySecondUavs) {
+ String value = historySecondUav.getValue();
+ Map map1 = JSON.parseObject(value, Map.class);
+ String flylat = map1.get("flylat").toString();
+ String flylon = map1.get("flylon").toString();
+ //���������������������������
+ boolean flag = isInPolygon(flylon,flylat,doubleArrayList);
+ if (flag){
+
+ list1.add(historySecondUav.getValue());
+ }
+ }
+// lists.add(list1);
+// String result = getResult(doubleArrayList);
+// rsMap.put(result,list1);
+ }
+
+
+ ArrayList<UAVResultDTO> uavResultDTOS = new ArrayList<>();
+ Set<String> strings = rsMap.keySet();
+ for (String string : strings) {
+ UAVResultDTO dto = new UAVResultDTO();
+ List<String> list1 = rsMap.get(string);
+ ArrayList<Double> TVOCArrayList = new ArrayList<>();
+ ArrayList<Double> PM10ArrayList = new ArrayList<>();
+ ArrayList<Double> PM25ArrayList = new ArrayList<>();
+ ArrayList<Double> SOArrayList = new ArrayList<>();
+ ArrayList<Double> NOArrayList = new ArrayList<>();
+ ArrayList<Double> QYArrayList = new ArrayList<>();
+ ArrayList<Double> COArrayList = new ArrayList<>();
+ ArrayList<Double> WDArrayList = new ArrayList<>();
+ ArrayList<Double> SHArrayList = new ArrayList<>();
+ for (String s : list1) {
+ JSONObject jsonObject = JSON.parseObject(s);
+ //tvoc
+ String a99054 = jsonObject.get("a99054").toString();
+ //pm2.5
+ String a34004 = jsonObject.get("a34004").toString();
+ //������������
+ String a21026 = jsonObject.get("a21026").toString();
+ ///������������
+ String a21004 = jsonObject.get("a21004").toString();
+// //������
+// String a01006 = jsonObject.get("a01006").toString();
+// if (a01006!=null){
+// QYArrayList.add(Double.parseDouble(a01006));
+// }
+ //pm10
+ String a34002 = jsonObject.get("a34002").toString();
+ //co
+ String a21005 = jsonObject.get("a21005").toString();
+ //������
+// String a01002 = jsonObject.get("a01002").toString();
+ //������
+// String a01001 = jsonObject.get("a01001").toString();
+ TVOCArrayList.add(Double.parseDouble(a99054));
+ PM10ArrayList.add(Double.parseDouble(a34002));
+ PM25ArrayList.add(Double.parseDouble(a34004));
+ SOArrayList.add(Double.parseDouble(a21026));
+ NOArrayList.add(Double.parseDouble(a21004));
+ COArrayList.add(Double.parseDouble(a21005));
+
+// WDArrayList.add(Double.parseDouble(a01001));
+// SHArrayList.add(Double.parseDouble(a01002));
+ }
+
+ double asDouble = COArrayList.stream().mapToInt(Double::intValue).average().getAsDouble();
+
+ }
+
+
+ return new ResultMessage(ResponseCodeEnum.SUCCESS.getCode(), ResponseCodeEnum.SUCCESS.getMsg(),null);
}
@@ -109,4 +288,240 @@
return new ResultMessage(ResponseCodeEnum.SUCCESS.getCode(), ResponseCodeEnum.SUCCESS.getMsg(),vo);
}
+ private static final double EARTH_RADIUS = 6378137;
+
+ private static final double R = 6371e3;
+ /** 180�� **/
+ private static final DecimalFormat df = new DecimalFormat("0.00000000");
+
+ /**
+ * ���������������������������������������������������������������������������
+ * @param angle ���������������������������������������������
+ * @param startLong ���������������
+ * @param startLat ���������������
+ * @param distance ���������������m
+ * @return
+ */
+ public static String[] calLocationByDistanceAndLocationAndDirection(double angle, double startLong,double startLat, double distance){
+ String[] result = new String[2];
+ //���������������������������������������
+ double �� = distance/R;
+ // ���������radian���������������������������
+ angle = Math.toRadians(angle);
+ startLong = Math.toRadians(startLong);
+ startLat = Math.toRadians(startLat);
+ double lat = Math.asin(Math.sin(startLat)*Math.cos(��)+Math.cos(startLat)*Math.sin(��)*Math.cos(angle));
+ double lon = startLong + Math.atan2(Math.sin(angle)*Math.sin(��)*Math.cos(startLat),Math.cos(��)-Math.sin(startLat)*Math.sin(lat));
+ // ���������������10���������������
+ lon = Math.toDegrees(lon);
+ lat = Math.toDegrees(lat);
+ result[0] = df.format(lon);
+ result[1] = df.format(lat);
+ return result;
+ }
+
+ /**
+ * ������������������������������������������
+ *
+ * @param longitude1 ���������������������
+ * @param latitude1 ���������������������
+ * @param longitude2 ���������������������
+ * @param latitude2 ���������������������
+ * @return ������������ ���������
+ */
+ public static double getDistance(double longitude1, double latitude1, double longitude2, double latitude2) {
+ // ������
+ double lat1 = Math.toRadians(latitude1);
+ double lat2 = Math.toRadians(latitude2);
+ // ������
+ double lng1 = Math.toRadians(longitude1);
+ double lng2 = Math.toRadians(longitude2);
+ // ������������
+ double a = lat1 - lat2;
+ // ������������
+ double b = lng1 - lng2;
+ // ���������������������������
+ double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) +
+ Math.cos(lat1) * Math.cos(lat2) * Math.pow(Math.sin(b / 2), 2)));
+ // ���������������������, ������������: ���
+ s = s * EARTH_RADIUS;
+ return s;
+ }
+
+
+ public static UAVResultDTO getResult(ArrayList<String[]> doubleArrayList){
+ UAVResultDTO uavResultDTO = new UAVResultDTO();
+ int total = doubleArrayList.size();
+ double X = 0, Y = 0, Z = 0;
+ for (int i = 0; i < total; i++) {
+ double lat, lon, x, y, z;
+ String[] strings = doubleArrayList.get(i);
+ lon = Double.parseDouble(strings[0]) * Math.PI / 180;
+ lat = Double.parseDouble(strings[1]) * Math.PI / 180;
+ x = Math.cos(lat) * Math.cos(lon);
+ y = Math.cos(lat) * Math.sin(lon);
+ 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 rsLon = Lon * 180 / Math.PI;
+ double rsLat = Lat * 180 / Math.PI;
+ uavResultDTO.setFlyLon(rsLon);
+ uavResultDTO.setFlyLat(rsLat);
+
+// return rsLon+"_"+rsLat;
+ return uavResultDTO;
+ }
+
+ /**
+ * ������������������������������GeneralPath������
+ *
+ * @param points ���������(������)
+ *
+ * @return GeneralPath������
+ */
+ public static GeneralPath genGeneralPath(ArrayList<Point2D.Double> points) {
+ GeneralPath path = new GeneralPath();
+
+ if (points.size() < 3) {
+ return null;
+ }
+
+ path.moveTo((float) points.get(0).getX(), (float) points.get(0).getY());
+
+ for (Iterator<Point2D.Double> it = points.iterator(); it.hasNext();) {
+ Point2D.Double point = (Point2D.Double) it.next();
+
+ path.lineTo((float) point.getX(), (float) point.getY());
+ }
+
+ path.closePath();
+
+ return path;
+ }
+ /**
+ * ������������������������������������������������������������������������������������������������������������������������true
+ * @param point ���������
+ * @param pts ������������������
+ * @return ������������������������true,������������false
+ */
+ public static boolean IsPtInPoly(Point2D.Double point, List<Point2D.Double> pts){
+
+ int N = pts.size();
+ boolean boundOrVertex = true; //���������������������������������������������������������������������������������������true
+ int intersectCount = 0;//cross points count of x
+ double precision = 2e-10; //���������������������������0���������������������
+ Point2D.Double p1, p2;//neighbour bound vertices
+ Point2D.Double p = point; //���������
+
+ p1 = pts.get(0);//left vertex
+ for(int i = 1; i <= N; ++i){//check all rays
+ if(p.equals(p1)){
+ return boundOrVertex;//p is an vertex
+ }
+
+ p2 = pts.get(i % N);
+ if(p.x < Math.min(p1.x, p2.x) || p.x > Math.max(p1.x, p2.x)){
+ p1 = p2;
+ continue;
+ }
+
+ if(p.x > Math.min(p1.x, p2.x) && p.x < Math.max(p1.x, p2.x)){
+ if(p.y <= Math.max(p1.y, p2.y)){
+ if(p1.x == p2.x && p.y >= Math.min(p1.y, p2.y)){
+ return boundOrVertex;
+ }
+
+ if(p1.y == p2.y){
+ if(p1.y == p.y){
+ return boundOrVertex;
+ }else{//before ray
+ ++intersectCount;
+ }
+ }else{
+ double xinters = (p.x - p1.x) * (p2.y - p1.y) / (p2.x - p1.x) + p1.y;
+ if(Math.abs(p.y - xinters) < precision){
+ return boundOrVertex;
+ }
+
+ if(p.y < xinters){
+ ++intersectCount;
+ }
+ }
+ }
+ }else{
+ if(p.x == p2.x && p.y <= p2.y){
+ Point2D.Double p3 = pts.get((i+1) % N);
+ if(p.x >= Math.min(p1.x, p3.x) && p.x <= Math.max(p1.x, p3.x)){
+ ++intersectCount;
+ }else{
+ intersectCount += 2;
+ }
+ }
+ }
+ p1 = p2;
+ }
+
+ if(intersectCount % 2 == 0){//���������������������
+ return false;
+ } else { //���������������������
+ return true;
+ }
+ }
+
+ /**
+ * ���������������������������������������������
+ * @param
+ * @param doubleArrayList ������������
+ * @return
+ */
+ public static boolean isInPolygon(String X,String Y,ArrayList<String[]> doubleArrayList){
+
+ double p_x =Double.parseDouble(X);
+ double p_y =Double.parseDouble(Y);
+ Point2D.Double point = new Point2D.Double(p_x, p_y);
+
+ List<Point2D.Double> pointList= new ArrayList<Point2D.Double>();
+
+ for (String[] strings : doubleArrayList) {
+ double polygonPoint_x=Double.parseDouble(strings[0]);
+ double polygonPoint_y=Double.parseDouble(strings[1]);
+ Point2D.Double polygonPoint = new Point2D.Double(polygonPoint_x,polygonPoint_y);
+ pointList.add(polygonPoint);
+ }
+ return IsPtInPoly(point,pointList);
+
+ }
+
+ public final static double x_pi = 3.14159265358979324 * 3000.0 / 180.0;
+
+ /**
+ * ���������������������������
+ *
+ * @param gd_lon ������
+ * @param gd_lat ������
+ * @return
+ */
+ public static Map<String, String> gd2bd(String gd_lon, String gd_lat) {
+ double longitude = Double.parseDouble(gd_lon);
+ double latitude = Double.parseDouble(gd_lat);
+ Map<String, String> data = new HashMap<>();
+ double x = longitude, y = latitude;
+ double z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * x_pi);
+ double theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * x_pi);
+ double bd_lon = z * Math.cos(theta) + 0.0065;
+ double bd_lat = z * Math.sin(theta) + 0.006;
+ data.put("lon", String.valueOf(bd_lon));
+ data.put("lat", String.valueOf(bd_lat));
+ return data;
+ }
+
}
--
Gitblit v1.8.0