InkSimplification.java

package edu.stanford.hci.r3.pen.ink;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.MathUtils;

public class InkSimplification {

        private int maxNumSamples = 3;

        private LinkedList<PenSample> recentSamples = new LinkedList<PenSample>();

        public InkSimplification() {

        }

        public boolean processNewSample(PenSample sample) {
                recentSamples.add(sample);
                if (recentSamples.size() <= maxNumSamples) {
                        // just return true, so we can collect more samples
                        return true;
                } else {
                        // check the bounding box in r,theta space...
                        // if it's big enough, we return true

                        double maxDR = Double.MIN_VALUE;
                        double maxDT = Double.MIN_VALUE;

                        // this is the new "origin"
                        PenSample firstSample = recentSamples.getFirst();
                        double firstX = firstSample.x;
                        double firstY = firstSample.y;

                        double firstTS = firstSample.timestamp;

                        List<Double> dThetas = new ArrayList<Double>();

                        for (PenSample s : recentSamples) {
                                // DebugUtils.println(s);
                                if (s.equals(firstSample)) {
                                        continue;
                                }

                                double dX = s.getX() - firstX;
                                double dY = s.getY() - firstY;
                                double dT = s.getTimestamp() - firstTS;

                                double dR = Math.sqrt(dX * dX + dY * dY);
                                double dTheta = Math.atan2(dY, dX);
                                dThetas.add(dTheta);
                                // System.out.println(theta + " ");
                                maxDR = Math.max(dR, maxDR); // min should be 0
                                maxDT = Math.max(dT, maxDT);
                        }

                        // by default, keep the sample
                        boolean shouldKeepNewSample = true;

                        // if the samples are too close to each other, then throw them out...
                        // DebugUtils.println("maxR: " + maxR);
                        if (maxDR < 30) {
                                shouldKeepNewSample = false;
                        }

                        // however, if we've turned enough, we should keep the new sample
                        double stdevTheta = MathUtils.standardDeviation(dThetas.toArray(new Double[0]));
                        // DebugUtils.println("stdevTheta: " + stdevTheta);
                        if (stdevTheta > 1) {
                                shouldKeepNewSample = true;
                        }

                        // however, if the person is writing really slowly, then keep the sample
                        // DebugUtils.println("maxDT: " + maxDT);
                        if (maxDT > 100) {
                                shouldKeepNewSample = true;
                        }

                        // yet, we should still throw away the samples that are WAY too close to each other... :)
                        if (maxDR < 5) {
                                shouldKeepNewSample = false;
                        }

                        if (shouldKeepNewSample) {
                                // remove the oldest sample
                                recentSamples.removeFirst();
                        } else {
                                // remove the newest sample
                                recentSamples.removeLast();
                        }

                        return shouldKeepNewSample;
                }
        }

        public void reset() {
                recentSamples.clear();
        }

        public void simplifyStroke(InkStroke currentStroke) {
                reset();

                List<PenSample> samples = currentStroke.getSamples();
                List<PenSample> newSamples = new ArrayList<PenSample>();

                for (PenSample s : samples) {
                        boolean shouldKeep = processNewSample(s);
                        if (shouldKeep) {
                                newSamples.add(s);
                        }
                }

                // we should ALWAYS keep the last sample
                PenSample lastSample = samples.get(samples.size() - 1);
                if (!newSamples.contains(lastSample)) {
                        newSamples.add(lastSample);
                }

                currentStroke.setSamples(newSamples);
        }
}

---