/* * Geopaparazzi - Digital field mapping on Android based devices * Copyright (C) 2016 HydroloGIS (www.hydrologis.com) * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ package eu.geopaparazzi.core.utilities; import java.util.ArrayList; import java.util.List; import com.vividsolutions.jts.geom.Coordinate; /** * Applies a sliding average on linear geometries for smoothing. * <p> * <p> * See: http://grass.osgeo.org/wiki/V.generalize_tutorial * </p> * * @author Andrea Antonello (www.hydrologis.com) */ public class FeatureSlidingAverage { private static final double DELTA = 0.00001; private final List<Coordinate> data; public FeatureSlidingAverage(List<Coordinate> data) { this.data = data; } public List<Coordinate> smooth(int lookAhead, boolean considerZ, double slide) { double sc; List<Coordinate> res = new ArrayList<Coordinate>(); Coordinate[] coordinates = data.toArray(new Coordinate[data.size()]); int n = coordinates.length; if (n < 4 * lookAhead) { /* * if lookahead is too large, lets put it as the * 20% of the number of coordinates */ lookAhead = (int) Math.floor(n * 0.2d); } if (lookAhead % 2 == 0) { lookAhead++; } if (lookAhead < 3) return null; int halfLookAhead = lookAhead / 2; if (halfLookAhead > coordinates.length) { throw new RuntimeException(); } int padding = 0; if (coordinates[0].distance(coordinates[n - 1]) < DELTA) { // we have a ring, extend it for smoothing int tmpN = lookAhead / 2; if (tmpN > n / 2) { tmpN = n / 2; } padding = tmpN; Coordinate[] ringCoordinates = new Coordinate[n + 2 * tmpN]; for (int i = 0; i < tmpN; i++) { ringCoordinates[i] = coordinates[n - (tmpN - i) - 1]; } System.arraycopy(coordinates, 0, ringCoordinates, tmpN, n); int index = 1; for (int i = ringCoordinates.length - padding; i < ringCoordinates.length; i++) { ringCoordinates[i] = coordinates[index++]; } coordinates = ringCoordinates; } n = n + 2 * padding; for (int j = 0; j < n; j++) { Coordinate tmp = new Coordinate(); res.add(tmp); } sc = 1.0 / (double) lookAhead; Coordinate pCoord = new Coordinate(); Coordinate sCoord = new Coordinate(); pointAssign(coordinates, 0, considerZ, pCoord); for (int i = 1; i < lookAhead; i++) { Coordinate tmpCoord = new Coordinate(); pointAssign(coordinates, i, considerZ, tmpCoord); pointAdd(pCoord, tmpCoord, pCoord); } /* and calculate the average of remaining points */ for (int i = halfLookAhead; i + halfLookAhead < n; i++) { Coordinate tmpCoord = new Coordinate(); pointAssign(coordinates, i, considerZ, sCoord); pointScalar(sCoord, 1.0 - slide, sCoord); pointScalar(pCoord, sc * slide, tmpCoord); pointAdd(tmpCoord, sCoord, res.get(i)); if (i + halfLookAhead + 1 < n) { pointAssign(coordinates, i - halfLookAhead, considerZ, tmpCoord); pointSubtract(pCoord, tmpCoord, pCoord); pointAssign(coordinates, i + halfLookAhead + 1, considerZ, tmpCoord); pointAdd(pCoord, tmpCoord, pCoord); } } for (int i = 0; i < halfLookAhead; i++) { Coordinate coordinate = res.get(i); coordinate.x = coordinates[i].x; coordinate.y = coordinates[i].y; coordinate.z = coordinates[i].z; } for (int i = n - halfLookAhead - 1; i < n; i++) { Coordinate coordinate = res.get(i); coordinate.x = coordinates[i].x; coordinate.y = coordinates[i].y; coordinate.z = coordinates[i].z; } if (padding != 0) { res = res.subList(padding, n - padding - 1); res.add(res.get(0)); } return res; } private void pointAssign(Coordinate[] coordinates, int index, boolean considerZ, Coordinate newAssignedCoordinate) { Coordinate coordinate = coordinates[index]; newAssignedCoordinate.x = coordinate.x; newAssignedCoordinate.y = coordinate.y; if (considerZ) { newAssignedCoordinate.z = coordinate.z; } else { newAssignedCoordinate.z = 0; } return; } private void pointAdd(Coordinate a, Coordinate b, Coordinate res) { res.x = a.x + b.x; res.y = a.y + b.y; res.z = a.z + b.z; } private void pointSubtract(Coordinate a, Coordinate b, Coordinate res) { res.x = a.x - b.x; res.y = a.y - b.y; res.z = a.z - b.z; } private void pointScalar(Coordinate a, double k, Coordinate res) { res.x = a.x * k; res.y = a.y * k; res.z = a.z * k; } }