/*This is a Java Program to implement Douglas-Peucker Algorithm. The Ramer–Douglas–Peucker algorithm (RDP) is an algorithm for reducing the number of points in a curve that is approximated by a series of points. This algorithm is also known under the names Douglas–Peucker algorithm, iterative end-point fit algorithm and split-and-merge algorithm. The purpose of the algorithm is, given a curve composed of line segments, to find a similar curve with fewer points. The algorithm defines ‘dissimilar’ based on the maximum distance between the original curve and the simplified curve. The simplified curve consists of a subset of the points that defined the original curve.*/

//This is a java program to filter out points using Douglas Peucker Algorithm
import static java.lang.Math.abs;
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

import java.util.Random;

class RamerDouglasPeuckerFilter
{

    private double epsilon;

    public RamerDouglasPeuckerFilter(double epsilon)
    {
        if (epsilon <= 0)
            {
                throw new IllegalArgumentException("Epsilon nust be > 0");
            }
        this.epsilon = epsilon;
    }

    public double[] filter(double[] data)
    {
        return ramerDouglasPeuckerFunction(data, 0, data.length - 1);
    }

    public double getEpsilon()
    {
        return epsilon;
    }

    protected double[] ramerDouglasPeuckerFunction(double[] points,
            int startIndex, int endIndex)
    {
        double dmax = 0;
        int idx = 0;
        double a = endIndex - startIndex;
        double b = points[endIndex] - points[startIndex];
        double c = -(b * startIndex - a * points[startIndex]);
        double norm = sqrt(pow(a, 2) + pow(b, 2));
        for (int i = startIndex + 1; i < endIndex; i++)
            {
                double distance = abs(b * i - a * points[i] + c) / norm;
                if (distance > dmax)
                    {
                        idx = i;
                        dmax = distance;
                    }
            }
        if (dmax >= epsilon)
            {
                double[] recursiveResult1 = ramerDouglasPeuckerFunction(points,
                                            startIndex, idx);
                double[] recursiveResult2 = ramerDouglasPeuckerFunction(points,
                                            idx, endIndex);
                double[] result = new double[(recursiveResult1.length - 1)
                                             + recursiveResult2.length];
                System.arraycopy(recursiveResult1, 0, result, 0,
                                 recursiveResult1.length - 1);
                System.arraycopy(recursiveResult2, 0, result,
                                 recursiveResult1.length - 1, recursiveResult2.length);
                return result;
            }
        else
            {
                return new double[] { points[startIndex], points[endIndex] };
            }
    }

    public void setEpsilon(double epsilon)
    {
        if (epsilon <= 0)
            {
                throw new IllegalArgumentException("Epsilon nust be > 0");
            }
        this.epsilon = epsilon;
    }

}

public class Douglas_Peucker_Algorithm
{
    public static void main(String args[])
    {
        Random random = new Random();
        double[] points = new double[20];
        double[] fpoints;
        for (int i = 0; i < points.length; i++)
            points[i] = random.nextInt(10);
        RamerDouglasPeuckerFilter rdpf = new RamerDouglasPeuckerFilter(1);
        fpoints = rdpf.filter(points);
        System.out.println("Orginal points");
        for (int i = 0; i < points.length; i++)
            System.out.print(points[i] + " ");
        System.out.println("\nFiltered points");
        for (int i = 0; i < fpoints.length; i++)
            System.out.print(fpoints[i] + " ");
    }
}

/*
Orginal points
5.0 0.0 8.0 7.0 2.0 9.0 4.0 4.0 0.0 7.0 4.0 1.0 9.0 6.0 8.0 9.0 6.0 6.0 9.0 6.0
Filtered points
5.0 0.0 8.0 2.0 9.0 0.0 7.0 1.0 9.0 6.0 9.0 6.0 9.0 6.0