package com.yssh.utils;
|
|
import java.awt.geom.Point2D;
|
import java.util.*;
|
|
import com.yssh.entity.Coordinate;
|
import com.yssh.entity.DistanceSuYuan;
|
import com.yssh.entity.MonitorPointPosition;
|
import org.geotools.geometry.DirectPosition2D;
|
import org.geotools.referencing.CRS;
|
import org.geotools.referencing.GeodeticCalculator;
|
import org.geotools.referencing.crs.DefaultGeographicCRS;
|
import org.opengis.referencing.crs.CoordinateReferenceSystem;
|
|
@SuppressWarnings("ALL")
|
public class CalculateUtils {
|
private final static double EARTH_RADIUS1 = 6371000;
|
|
private static double rad(double d) {
|
return d * Math.PI / 180.0;
|
}
|
|
public static double getDistance1(double lon1, double lat1, double lon2, double lat2) {
|
double radLat1 = rad(lat1);
|
double radLat2 = rad(lat2);
|
double a = radLat1 - radLat2;
|
double b = rad(lon1) - rad(lon2);
|
double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
|
|
s = s * EARTH_RADIUS1;
|
|
return round2(s);
|
}
|
|
public static double getDistance2(double x1, double y1, double x2, double y2) {
|
GeodeticCalculator geodeticCalculator = new GeodeticCalculator(DefaultGeographicCRS.WGS84);
|
|
geodeticCalculator.setStartingGeographicPoint(x1, y1);
|
|
geodeticCalculator.setDestinationGeographicPoint(x2, y2);
|
|
double distance = geodeticCalculator.getOrthodromicDistance();
|
|
return round2(distance);
|
}
|
|
public static double round2(double d) {
|
return ((long) (d * 100)) / 100D;
|
}
|
|
public static double round6(double d) {
|
return ((long) (d * 1000000)) / 1000000D;
|
}
|
|
public static double getAngle(double x1, double y1, double x2, double y2) {
|
try {
|
CoordinateReferenceSystem crs = CRS.decode("EPSG:4326");
|
DirectPosition2D p1 = new DirectPosition2D(crs, x1, y1);
|
DirectPosition2D p2 = new DirectPosition2D(crs, x2, y2);
|
|
GeodeticCalculator gc = new GeodeticCalculator();
|
gc.setStartingGeographicPoint(p1);
|
gc.setDestinationGeographicPoint(p2);
|
|
double angle = gc.getAzimuth();
|
|
return round2(angle);
|
} catch (Exception ex) {
|
return 0;
|
}
|
}
|
|
public static double getAngle2(double x1, double y1, double x2, double y2) {
|
try {
|
DirectPosition2D p1 = new DirectPosition2D(x1, y1);
|
DirectPosition2D p2 = new DirectPosition2D(x2, y2);
|
|
GeodeticCalculator gc = new GeodeticCalculator();
|
gc.setStartingGeographicPoint(p1);
|
gc.setDestinationGeographicPoint(p2);
|
|
double angle = gc.getAzimuth();
|
|
return round2(angle);
|
} catch (Exception ex) {
|
return 0;
|
}
|
}
|
|
public static Coordinate getCoordinate(DistanceSuYuan su) {
|
String[] sirs = su.getId().split("_");
|
|
int x = Integer.parseInt(sirs[0]);
|
int y = Integer.parseInt(sirs[1]);
|
double lon = CalculateUtils.getLon(x, y);
|
double lat = CalculateUtils.getLat(x, y);
|
|
return new Coordinate(lon, lat);
|
}
|
|
public static double getLon(int x, int y) {
|
double lon = 115.9165227 + 0.000116732 * (x - 0.5) + 0.00000116862 * (y - 0.5);
|
if (lon < 115 || lon > 116) {
|
System.out.println("lon is invalid");
|
}
|
|
return round6(lon);
|
}
|
|
public static double getLat(int x, int y) {
|
double lat = 39.77250000 + 0.000001000 * (x - 0.5) - 0.00009000000 * (y - 0.5);
|
if (lat < 39 || lat > 40) {
|
System.out.println("lat is invalid");
|
}
|
|
return round6(lat);
|
}
|
|
public static List<String> assembleId(List<MonitorPointPosition> checkPoints) {
|
List<String> ids2d = new ArrayList<>();
|
for (MonitorPointPosition point : checkPoints) {
|
// ids2d.add(point.getX() + "_" + point.getY() + "_" + point.getZ());
|
ids2d.add(point.getX() + "_" + point.getY() + "_" + 0);
|
}
|
return ids2d;
|
}
|
|
public static List<String> aloneCrosswiseExtend(MonitorPointPosition checkPoint, int range) {
|
List<String> ids = new ArrayList<>();
|
Integer x = checkPoint.getX();
|
Integer y = checkPoint.getY();
|
for (int i = x - range / 2; i <= x + range / 2; i++) {
|
for (int j = y - range / 2; j <= y + range / 2; j++) {
|
// ids.add(i + "_" + j + "_" + checkPoint.getZ());
|
ids.add(i + "_" + j + "_" + 0);
|
}
|
}
|
return ids;
|
}
|
|
public static String getFilterByExtend(MonitorPointPosition point, int range) {
|
Integer x = point.getX();
|
Integer y = point.getY();
|
|
return String.format("x between %d and %d and y between %d and %d", x - range / 2, x + range / 2, y - range / 2, y + range / 2);
|
}
|
|
public static List<String> temporary(MonitorPointPosition point, int range) {
|
List<String> ids3d = new ArrayList<>();
|
Integer x = point.getX();
|
Integer y = point.getY();
|
Integer z = point.getZ();
|
for (int i = x - range / 2; i <= x + range / 2; i++) {
|
for (int j = y - range / 2; j <= y + range / 2; j++) {
|
for (int k = z; k < 100; k++) {
|
ids3d.add(i + "_" + j + "_" + k);
|
}
|
}
|
}
|
return ids3d;
|
}
|
|
public static String getDir(double direction) {
|
if (direction < 0) {
|
direction = direction + 360;
|
}
|
if (direction > 360) {
|
direction = direction - 360;
|
}
|
|
if (direction >= 22.5 && direction < 67.5)
|
return "东北";
|
if (direction >= 67.5 && direction < 112.5)
|
return "东";
|
if (direction >= 112.5 && direction < 157.5)
|
return "东南";
|
if (direction >= 157.5 && direction < 202.5)
|
return "南";
|
if (direction >= 202.5 && direction < 247.5)
|
return "西南";
|
if (direction >= 247.5 && direction < 292.5)
|
return "西";
|
if (direction >= 292.5 && direction < 337.5)
|
return "西北";
|
|
return "北";
|
}
|
|
public static List<Coordinate> calcRect(double x, double y) {
|
double buffer = 10;
|
double dis = round6(Math.sqrt(Math.pow(buffer / 2, 2) * 2));
|
|
List<Coordinate> list = new ArrayList<>();
|
list.add(getPointByDisAndAngle(x, y, 315, dis));
|
list.add(getPointByDisAndAngle(x, y, 45, dis));
|
list.add(getPointByDisAndAngle(x, y, 135, dis));
|
list.add(getPointByDisAndAngle(x, y, 225, dis));
|
|
return list;
|
}
|
|
private static Coordinate getPointByDisAndAngle(double x, double y, double angle, double dis) {
|
try {
|
DirectPosition2D p1 = new DirectPosition2D(x, y);
|
|
GeodeticCalculator gc = new GeodeticCalculator();
|
gc.setStartingGeographicPoint(p1);
|
gc.setDirection(angle, dis);
|
|
Point2D dest = gc.getDestinationGeographicPoint();
|
double newX = round6(dest.getX());
|
double newY = round6(dest.getY());
|
|
return new Coordinate(newX, newY);
|
} catch (Exception ex) {
|
return new Coordinate();
|
}
|
}
|
|
public static Double getWindSpeed(double v, double u) {
|
return round6(Math.sqrt(v * v + u * u));
|
}
|
|
public static double getWindDirection(double v, double u) {
|
double result = Math.atan(u / (v + Math.pow(10, -5))) / Math.PI * 180;
|
if (result < 0) {
|
result += 180;
|
} else if (u < 0 && v > 0) {
|
result += 360;
|
}
|
|
return round6(result);
|
}
|
|
public static List<Map<String, Object>> sort(List<Map<String, Object>> list, final String property, final boolean order) {
|
if (list == null || property == null) {
|
return null;
|
}
|
Collections.sort(list, new Comparator<Map<String, Object>>() {
|
@Override
|
public int compare(Map<String, Object> o1, Map<String, Object> o2) {
|
try {
|
Object oo1 = o1.get(property);
|
Object oo2 = o2.get(property);
|
if (oo1 == null || "null".equals(oo1.toString()) || "".equals(oo1.toString()) || oo1.toString().endsWith("999")) {
|
oo1 = 0;
|
}
|
if (oo2 == null || "null".equals(oo2.toString()) || "".equals(oo2.toString()) || oo2.toString().endsWith("999")) {
|
oo2 = 0;
|
}
|
if (order) {
|
if (Double.parseDouble(oo1.toString()) < Double.parseDouble(oo2.toString())) {
|
return 1;
|
}
|
} else {
|
if (Double.parseDouble(oo1.toString()) > Double.parseDouble(oo2.toString())) {
|
return 1;
|
}
|
}
|
if (Double.parseDouble(oo1.toString()) == Double.parseDouble(oo2.toString())) {
|
return 0;
|
}
|
} catch (Exception ex) {
|
System.out.println(ex.getMessage());
|
}
|
return -1;
|
}
|
});
|
return list;
|
}
|
}
|
