From 59416923dcb3a756eaf532cc4259f2f6625c0762 Mon Sep 17 00:00:00 2001 From: Anton Tananaev Date: Sun, 31 Mar 2019 22:35:39 -0700 Subject: Convert project to gradle --- .../java/org/traccar/geofence/GeofenceCircle.java | 98 ++++++++++++ .../org/traccar/geofence/GeofenceGeometry.java | 50 +++++++ .../java/org/traccar/geofence/GeofencePolygon.java | 164 +++++++++++++++++++++ .../org/traccar/geofence/GeofencePolyline.java | 107 ++++++++++++++ 4 files changed, 419 insertions(+) create mode 100644 src/main/java/org/traccar/geofence/GeofenceCircle.java create mode 100644 src/main/java/org/traccar/geofence/GeofenceGeometry.java create mode 100644 src/main/java/org/traccar/geofence/GeofencePolygon.java create mode 100644 src/main/java/org/traccar/geofence/GeofencePolyline.java (limited to 'src/main/java/org/traccar/geofence') diff --git a/src/main/java/org/traccar/geofence/GeofenceCircle.java b/src/main/java/org/traccar/geofence/GeofenceCircle.java new file mode 100644 index 000000000..f6fca63ca --- /dev/null +++ b/src/main/java/org/traccar/geofence/GeofenceCircle.java @@ -0,0 +1,98 @@ +/* + * Copyright 2016 Anton Tananaev (anton@traccar.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.traccar.geofence; + +import java.text.DecimalFormat; +import java.text.ParseException; + +import org.traccar.helper.DistanceCalculator; + +public class GeofenceCircle extends GeofenceGeometry { + + private double centerLatitude; + private double centerLongitude; + private double radius; + + public GeofenceCircle() { + } + + public GeofenceCircle(String wkt) throws ParseException { + fromWkt(wkt); + } + + public GeofenceCircle(double latitude, double longitude, double radius) { + this.centerLatitude = latitude; + this.centerLongitude = longitude; + this.radius = radius; + } + + public double distanceFromCenter(double latitude, double longitude) { + return DistanceCalculator.distance(centerLatitude, centerLongitude, latitude, longitude); + } + + @Override + public boolean containsPoint(double latitude, double longitude) { + return distanceFromCenter(latitude, longitude) <= radius; + } + + @Override + public String toWkt() { + String wkt = ""; + wkt = "CIRCLE ("; + wkt += String.valueOf(centerLatitude); + wkt += " "; + wkt += String.valueOf(centerLongitude); + wkt += ", "; + DecimalFormat format = new DecimalFormat("0.#"); + wkt += format.format(radius); + wkt += ")"; + return wkt; + } + + @Override + public void fromWkt(String wkt) throws ParseException { + if (!wkt.startsWith("CIRCLE")) { + throw new ParseException("Mismatch geometry type", 0); + } + String content = wkt.substring(wkt.indexOf("(") + 1, wkt.indexOf(")")); + if (content == null || content.equals("")) { + throw new ParseException("No content", 0); + } + String[] commaTokens = content.split(","); + if (commaTokens.length != 2) { + throw new ParseException("Not valid content", 0); + } + String[] tokens = commaTokens[0].split("\\s"); + if (tokens.length != 2) { + throw new ParseException("Too much or less coordinates", 0); + } + try { + centerLatitude = Double.parseDouble(tokens[0]); + } catch (NumberFormatException e) { + throw new ParseException(tokens[0] + " is not a double", 0); + } + try { + centerLongitude = Double.parseDouble(tokens[1]); + } catch (NumberFormatException e) { + throw new ParseException(tokens[1] + " is not a double", 0); + } + try { + radius = Double.parseDouble(commaTokens[1]); + } catch (NumberFormatException e) { + throw new ParseException(commaTokens[1] + " is not a double", 0); + } + } +} diff --git a/src/main/java/org/traccar/geofence/GeofenceGeometry.java b/src/main/java/org/traccar/geofence/GeofenceGeometry.java new file mode 100644 index 000000000..857ba3414 --- /dev/null +++ b/src/main/java/org/traccar/geofence/GeofenceGeometry.java @@ -0,0 +1,50 @@ +/* + * Copyright 2016 Anton Tananaev (anton@traccar.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.traccar.geofence; + +import java.text.ParseException; + +public abstract class GeofenceGeometry { + + public abstract boolean containsPoint(double latitude, double longitude); + + public abstract String toWkt(); + + public abstract void fromWkt(String wkt) throws ParseException; + + public static class Coordinate { + + private double lat; + private double lon; + + public double getLat() { + return lat; + } + + public void setLat(double lat) { + this.lat = lat; + } + + public double getLon() { + return lon; + } + + public void setLon(double lon) { + this.lon = lon; + } + } + +} diff --git a/src/main/java/org/traccar/geofence/GeofencePolygon.java b/src/main/java/org/traccar/geofence/GeofencePolygon.java new file mode 100644 index 000000000..2048ba26d --- /dev/null +++ b/src/main/java/org/traccar/geofence/GeofencePolygon.java @@ -0,0 +1,164 @@ +/* + * Copyright 2016 Anton Tananaev (anton@traccar.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.traccar.geofence; + +import java.text.ParseException; +import java.util.ArrayList; + +public class GeofencePolygon extends GeofenceGeometry { + + public GeofencePolygon() { + } + + public GeofencePolygon(String wkt) throws ParseException { + fromWkt(wkt); + } + + private ArrayList coordinates; + + private double[] constant; + private double[] multiple; + + private boolean needNormalize = false; + + private void precalc() { + if (coordinates == null) { + return; + } + + int polyCorners = coordinates.size(); + int i; + int j = polyCorners - 1; + + if (constant != null) { + constant = null; + } + if (multiple != null) { + multiple = null; + } + + constant = new double[polyCorners]; + multiple = new double[polyCorners]; + + boolean hasNegative = false; + boolean hasPositive = false; + for (i = 0; i < polyCorners; i++) { + if (coordinates.get(i).getLon() > 90) { + hasPositive = true; + } else if (coordinates.get(i).getLon() < -90) { + hasNegative = true; + } + } + needNormalize = hasPositive && hasNegative; + + for (i = 0; i < polyCorners; j = i++) { + if (normalizeLon(coordinates.get(j).getLon()) == normalizeLon(coordinates.get(i).getLon())) { + constant[i] = coordinates.get(i).getLat(); + multiple[i] = 0; + } else { + constant[i] = coordinates.get(i).getLat() + - (normalizeLon(coordinates.get(i).getLon()) * coordinates.get(j).getLat()) + / (normalizeLon(coordinates.get(j).getLon()) - normalizeLon(coordinates.get(i).getLon())) + + (normalizeLon(coordinates.get(i).getLon()) * coordinates.get(i).getLat()) + / (normalizeLon(coordinates.get(j).getLon()) - normalizeLon(coordinates.get(i).getLon())); + multiple[i] = (coordinates.get(j).getLat() - coordinates.get(i).getLat()) + / (normalizeLon(coordinates.get(j).getLon()) - normalizeLon(coordinates.get(i).getLon())); + } + } + } + + private double normalizeLon(double lon) { + if (needNormalize && lon < -90) { + return lon + 360; + } + return lon; + } + + @Override + public boolean containsPoint(double latitude, double longitude) { + + int polyCorners = coordinates.size(); + int i; + int j = polyCorners - 1; + double longitudeNorm = normalizeLon(longitude); + boolean oddNodes = false; + + for (i = 0; i < polyCorners; j = i++) { + if (normalizeLon(coordinates.get(i).getLon()) < longitudeNorm + && normalizeLon(coordinates.get(j).getLon()) >= longitudeNorm + || normalizeLon(coordinates.get(j).getLon()) < longitudeNorm + && normalizeLon(coordinates.get(i).getLon()) >= longitudeNorm) { + oddNodes ^= longitudeNorm * multiple[i] + constant[i] < latitude; + } + } + return oddNodes; + } + + @Override + public String toWkt() { + StringBuilder buf = new StringBuilder(); + buf.append("POLYGON (("); + for (Coordinate coordinate : coordinates) { + buf.append(String.valueOf(coordinate.getLat())); + buf.append(" "); + buf.append(String.valueOf(coordinate.getLon())); + buf.append(", "); + } + return buf.substring(0, buf.length() - 2) + "))"; + } + + @Override + public void fromWkt(String wkt) throws ParseException { + if (coordinates == null) { + coordinates = new ArrayList<>(); + } else { + coordinates.clear(); + } + + if (!wkt.startsWith("POLYGON")) { + throw new ParseException("Mismatch geometry type", 0); + } + String content = wkt.substring(wkt.indexOf("((") + 2, wkt.indexOf("))")); + if (content.isEmpty()) { + throw new ParseException("No content", 0); + } + String[] commaTokens = content.split(","); + if (commaTokens.length < 3) { + throw new ParseException("Not valid content", 0); + } + + for (String commaToken : commaTokens) { + String[] tokens = commaToken.trim().split("\\s"); + if (tokens.length != 2) { + throw new ParseException("Here must be two coordinates: " + commaToken, 0); + } + Coordinate coordinate = new Coordinate(); + try { + coordinate.setLat(Double.parseDouble(tokens[0])); + } catch (NumberFormatException e) { + throw new ParseException(tokens[0] + " is not a double", 0); + } + try { + coordinate.setLon(Double.parseDouble(tokens[1])); + } catch (NumberFormatException e) { + throw new ParseException(tokens[1] + " is not a double", 0); + } + coordinates.add(coordinate); + } + precalc(); + } + +} diff --git a/src/main/java/org/traccar/geofence/GeofencePolyline.java b/src/main/java/org/traccar/geofence/GeofencePolyline.java new file mode 100644 index 000000000..d84f512e3 --- /dev/null +++ b/src/main/java/org/traccar/geofence/GeofencePolyline.java @@ -0,0 +1,107 @@ +/* + * Copyright 2016 Anton Tananaev (anton@traccar.org) + * Copyright 2016 Andrey Kunitsyn (andrey@traccar.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.traccar.geofence; + +import java.text.ParseException; +import java.util.ArrayList; + +import org.traccar.helper.DistanceCalculator; + +public class GeofencePolyline extends GeofenceGeometry { + + private ArrayList coordinates; + private double distance; + + public GeofencePolyline() { + } + + public GeofencePolyline(String wkt, double distance) throws ParseException { + fromWkt(wkt); + this.distance = distance; + } + + @Override + public boolean containsPoint(double latitude, double longitude) { + for (int i = 1; i < coordinates.size(); i++) { + if (DistanceCalculator.distanceToLine( + latitude, longitude, coordinates.get(i - 1).getLat(), coordinates.get(i - 1).getLon(), + coordinates.get(i).getLat(), coordinates.get(i).getLon()) <= distance) { + return true; + } + } + return false; + } + + @Override + public String toWkt() { + StringBuilder buf = new StringBuilder(); + buf.append("LINESTRING ("); + for (Coordinate coordinate : coordinates) { + buf.append(String.valueOf(coordinate.getLat())); + buf.append(" "); + buf.append(String.valueOf(coordinate.getLon())); + buf.append(", "); + } + return buf.substring(0, buf.length() - 2) + ")"; + } + + @Override + public void fromWkt(String wkt) throws ParseException { + if (coordinates == null) { + coordinates = new ArrayList<>(); + } else { + coordinates.clear(); + } + + if (!wkt.startsWith("LINESTRING")) { + throw new ParseException("Mismatch geometry type", 0); + } + String content = wkt.substring(wkt.indexOf("(") + 1, wkt.indexOf(")")); + if (content.isEmpty()) { + throw new ParseException("No content", 0); + } + String[] commaTokens = content.split(","); + if (commaTokens.length < 2) { + throw new ParseException("Not valid content", 0); + } + + for (String commaToken : commaTokens) { + String[] tokens = commaToken.trim().split("\\s"); + if (tokens.length != 2) { + throw new ParseException("Here must be two coordinates: " + commaToken, 0); + } + Coordinate coordinate = new Coordinate(); + try { + coordinate.setLat(Double.parseDouble(tokens[0])); + } catch (NumberFormatException e) { + throw new ParseException(tokens[0] + " is not a double", 0); + } + try { + coordinate.setLon(Double.parseDouble(tokens[1])); + } catch (NumberFormatException e) { + throw new ParseException(tokens[1] + " is not a double", 0); + } + coordinates.add(coordinate); + } + + } + + public void setDistance(double distance) { + this.distance = distance; + } + +} -- cgit v1.2.3