# hgoebl/simplify-java

Simplification of a 2D-polyline or a 3D-polyline
Java JavaScript
Switch branches/tags
Nothing to show
Fetching latest commit…
Cannot retrieve the latest commit at this time.
 Failed to load latest commit information. src Dec 1, 2015 .gitignore Jan 10, 2014 LICENSE Jul 12, 2013 README.md Dec 1, 2015 pom.xml Dec 1, 2015

# simplify-java

Simplification of a 2D-polyline or a 3D-polyline.

• Uses Radial-Distance algorithm (fast) or Douglas-Peucker (high quality) algorithm
• Port of mourner / simplify-js, a High-performance JavaScript 2D/3D polyline simplification library by Vladimir Agafonkin
• Can handle arbitrary objects carrying coordinates (2D, 3D)
• either by implementing an interface
• or by providing a helper extracting the coordinates
• Leaves the objects untouched, just creates a new array referencing the simplified points
• requires Java 5
• Maven Build
• JUnit-tested
• 94% lines covered
• reference data is created by "original" JavaScript implementation (Version 1.1.0)

# Example

```    // create an instance of the simplifier (empty array needed by List.toArray)
Simplify<Point> simplify = new Simplify<Point>(new MyPoint[0]);

// here we have an array with hundreds of points
Point[] allPoints = ...
double tolerance = ...
boolean highQuality = true; // Douglas-Peucker, false for Radial-Distance

// run simplification process
Point[] lessPoints = simplify.simplify(allPoints, tolerance, highQuality);```

Please note The algorithm squares differences of x, y and z coordinates. If this difference is less than 1, the square of it will get even less. In such cases, the tolerance has negative effect.

Solution: multiply your coordinates by a factor so the values are shifted in a way so that taking the square of the differences creates greater values.

If your Points don't have the `com.goebl.simplify.Point` interface, you can implement it on your Point-Class, or (better w.r.t. separation of concerns) provide an implementation of the `PointExtractor` interface.

Here is an example (taken from the test cases):

Example for your own point-class, let's assume it's not possible/desirable to let it implement com.goebl.simplify.Point interface:

```public class LatLng {
private final double lat;
private final double lng;

public LatLng(double lat, double lng) {
this.lat = lat;
this.lng = lng;
}

public double getLat() {
return lat;
}

public double getLng() {
return lng;
}
}```

In the class where you simplify the points, you need a PointExtractor. As mentioned above, the resulting x and y values are shifted in a space where delta-x and delta-y are no longer very small numbers below 1:

```private static PointExtractor<LatLng> latLngPointExtractor = new PointExtractor<LatLng>() {
@Override
public double getX(LatLng point) {
return point.getLat() * 1000000;
}

@Override
public double getY(LatLng point) {
return point.getLng() * 1000000;
}
};```

Simplification now works like this. Using a `PointExtractor` has the positive effect that you get an array of your original points, not copies:

```LatLng[] coords = ... // the array of your "original" points

Simplify<LatLng> simplify = new Simplify<LatLng>(new LatLng[0], latLngPointExtractor);

LatLng[] simplified = simplify.simplify(coords, 20f, false);```

For more examples see src/test/java/**/*Test.

# Maven Coordinates

```<dependency>
<groupId>com.goebl</groupId>
<artifactId>simplify</artifactId>
<version>1.0.0</version>

<!-- or -->

<groupId>com.goebl</groupId>
<artifactId>simplify</artifactId>
<version>1.0.1-SNAPSHOT</version>
</dependency>```

``````'com.goebl:simplify:1.0.0'