InkCollector.java

package edu.stanford.hci.r3.events.handlers;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import edu.stanford.hci.r3.events.EventHandler;
import edu.stanford.hci.r3.events.PenEvent;
import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.pen.ink.Ink;
import edu.stanford.hci.r3.pen.ink.InkStroke;
import edu.stanford.hci.r3.units.PatternDots;
import edu.stanford.hci.r3.units.Units;
import edu.stanford.hci.r3.units.coordinates.PercentageCoordinates;
import edu.stanford.hci.r3.util.MathUtils;

public abstract class InkCollector extends EventHandler {

        private class InkNotifier implements Runnable {

                private boolean doNotNotify;

                private InkStroke lastTempStroke;

                private List<PenSample> strokeSamples;

                public InkNotifier(List<PenSample> currentStrokeSamples, InkStroke tempStroke) {
                        strokeSamples = currentStrokeSamples;
                        lastTempStroke = tempStroke;
                }

                public void run() {
                        try {
                                Thread.sleep(MILLIS_TO_DELAY);
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                        if (doNotNotify) {
                                // someone told us to cancel
                                return;
                        }

                        if (lastTempStroke != null) {
                                strokes.remove(lastTempStroke);
                        }

                        // System.out.println(currentStrokeSamples.size() + " samples in
                        // this stroke.");
                        addStrokeAndNotifyListeners(strokeSamples);
                }

                public void setDoNotNotify(boolean b) {
                        doNotNotify = b;
                }
        }

        private static final PatternDots DOTS = new PatternDots();

        private static final int MAX_MILLIS_FOR_PEN_ERROR = 20;

        private static final int MILLIS_TO_DELAY = 21;

        private List<PenSample> currentStrokeSamples = new ArrayList<PenSample>();

        private long currPenDownTime;

        private double distanceThreshold = 0;

        private double distanceTraveled = 0;

        private InkNotifier lastInkNotifier;

        private long lastPenUpTime;

        private double lastXForDistanceMeasurements;

        private double lastYForDistanceMeasurements;

        private InkStroke mostRecentlyAddedStroke;

        private InkStroke mostRecentlyAddedTemporaryStroke;

        private int newInkMarker = 0;

        private boolean notifyAfterEnoughDistance = false;

        private List<InkStroke> strokes = Collections.synchronizedList(new ArrayList<InkStroke>());

        private long timeDiffBetweenPenUpAndPenDown;

        public InkCollector() {

        };

        private synchronized void addStrokeAndNotifyListeners(List<PenSample> strokeSamples) {
                mostRecentlyAddedStroke = new InkStroke(strokeSamples, DOTS);
                strokes.add(mostRecentlyAddedStroke);
                contentArrived();
        }

        private synchronized void addStrokeTemporarilyAndNotifyListeners(List<PenSample> strokeSamples) {
                if (mostRecentlyAddedTemporaryStroke != null) {
                        strokes.remove(mostRecentlyAddedTemporaryStroke);
                }
                mostRecentlyAddedTemporaryStroke = new InkStroke(strokeSamples, DOTS);
                strokes.add(mostRecentlyAddedTemporaryStroke);
                contentArrived();
        }

        public void clear() {
                strokes.clear();
                currentStrokeSamples.clear();
                newInkMarker = 0;
        }

        public abstract void contentArrived();

        public Ink getInk() {
                return new Ink(new ArrayList<InkStroke>(strokes));
        }

        public Ink getNewInkOnly() {
                Ink newInk = new Ink(
                                new ArrayList<InkStroke>(strokes.subList(newInkMarker, strokes.size())));
                newInkMarker = strokes.size();
                return newInk;
        }

        public int getNumStrokesCollected() {
                return strokes.size();
        }

        public long getTimestampOfMostRecentInkStroke() {
                if (strokes != null && strokes.size() >= 1) {
                        return strokes.get(strokes.size() - 1).getLastTimestamp();
                } else {
                        return -1;
                }
        }

        public Date getTimestampOfMostRecentPenUp() {
                return new Date(lastPenUpTime);
        }

        /*
         * (non-Javadoc)
         * 
         * @see edu.stanford.hci.r3.events.EventHandler#handleEvent(edu.stanford.hci.r3.events.PenEvent)
         */
        @Override
        public void handleEvent(PenEvent event) {

                final PercentageCoordinates percentageLocation = event.getPercentageLocation();
                final Units xPct = percentageLocation.getX();
                final Units yPct = percentageLocation.getY();
                final long timestamp = event.getTimestamp();

                // collect the ink strokes in default units? (i.e., PatternDots?)
                // the thing that renders the ink should decide how to scale it
                final double xDots = xPct.getValueInPatternDots();
                final double yDots = yPct.getValueInPatternDots();

                if (event.isTypePenDown()) {
                        currPenDownTime = System.currentTimeMillis();
                        timeDiffBetweenPenUpAndPenDown = currPenDownTime - lastPenUpTime;
                        // DebugUtils.println("The pen was up for " +
                        // timeDiffBetweenPenUpAndPenDown + "
                        // milliseconds");

                        // 20 milliseconds (1/50 of a second) is probably faster than a
                        // human can go up and down
                        if (timeDiffBetweenPenUpAndPenDown > MAX_MILLIS_FOR_PEN_ERROR /* millis */) {
                                // not a pen error!

                                // let the last ink notifier run
                                lastInkNotifier = null;

                                // reset the distance traveled
                                distanceTraveled = 0;
                                lastXForDistanceMeasurements = xDots;
                                lastYForDistanceMeasurements = yDots;

                                // We should start a new stroke!
                                currentStrokeSamples = new ArrayList<PenSample>();
                                currentStrokeSamples.add(new PenSample(xDots, yDots, 128, timestamp));
                        } else {
                                // we'll assume this is a pen manufacturing error (jitter)!

                                // "kill" the last notifier if possible (best effort)
                                lastInkNotifier.setDoNotNotify(true);
                                lastInkNotifier = null;

                                // add this sample back to the current stroke
                                currentStrokeSamples.add(new PenSample(xDots, yDots, 128, timestamp));
                        }
                } else if (event.isTypePenUp()) {
                        // the pen is lifted from the page

                        // record the time of the pen up
                        lastPenUpTime = System.currentTimeMillis();

                        // we need to notify our listeners
                        // notify after a short delay, because we may actually update the
                        // current stroke
                        // if there is a pen error
                        lastInkNotifier = new InkNotifier(currentStrokeSamples,
                                        mostRecentlyAddedTemporaryStroke);
                        new Thread(lastInkNotifier).start();

                        // System.out.println("Collected " + strokes.size() + " strokes so
                        // far.");
                } else { // regular sample
                        currentStrokeSamples.add(new PenSample(xDots, yDots, 128, timestamp));

                        // are we supposed to notify after enough distance?
                        if (notifyAfterEnoughDistance) {
                                // assume zero distance for now...
                                distanceTraveled += MathUtils.distance(xDots, yDots, //
                                                lastXForDistanceMeasurements, lastYForDistanceMeasurements);
                                lastXForDistanceMeasurements = xDots;
                                lastYForDistanceMeasurements = yDots;

                                if (distanceTraveled > distanceThreshold) {
                                        addStrokeTemporarilyAndNotifyListeners(currentStrokeSamples);
                                }
                        }
                }
        }

        public void saveInkToXMLFile(File xmlFile) {
                new Ink(strokes).saveToXMLFile(xmlFile);
        }

        public void setNotifyDistance(Units notifyAfterThisMuchPenMovement) {
                if (notifyAfterThisMuchPenMovement == null) {
                        distanceThreshold = 0;
                        notifyAfterEnoughDistance = false;
                } else {
                        distanceThreshold = notifyAfterThisMuchPenMovement.getValueInPatternDots();
                        notifyAfterEnoughDistance = true;
                }
        }

        @Override
        public String toString() {
                return "Ink Collector [" + strokes.size() + " strokes]";
        }
}

---