InkStroke.java

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

import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.units.PatternDots;
import edu.stanford.hci.r3.units.Units;
import edu.stanford.hci.r3.util.MathUtils;

public class InkStroke {

        private static final PatternDots DEFAULT_REFERENCE_UNIT = new PatternDots();

        private double maxX = Double.MIN_VALUE;

        private double maxY = Double.MIN_VALUE;

        private double minX = Double.MAX_VALUE;

        private double minY = Double.MAX_VALUE;

        private Units referenceUnit;

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

        private double strokeWidth = 1.2;

        public InkStroke() {
                referenceUnit = DEFAULT_REFERENCE_UNIT;
        }

        public InkStroke(Collection<PenSample> currentStrokeSamples, Units reference) {
                referenceUnit = reference;
                for (PenSample s : currentStrokeSamples) {
                        addSample(s.x, s.y, s.force, s.timestamp);
                }
        }

        public InkStroke(List<PenSample> stroke) {
                this(stroke, DEFAULT_REFERENCE_UNIT);
        }

        public void addSample(double x, double y, int force, long ts) {
                samples.add(new PenSample(x, y, force, ts));

                // update maxs and mins
                minX = Math.min(x, minX);
                minY = Math.min(y, minY);
                maxX = Math.max(x, maxX);
                maxY = Math.max(y, maxY);
        }

        public void addSample(PenSample penSample) {
                samples.add(penSample);

                // update maxs and mins
                minX = Math.min(penSample.x, minX);
                minY = Math.min(penSample.y, minY);
                maxX = Math.max(penSample.x, maxX);
                maxY = Math.max(penSample.y, maxY);
        }

        public double getArea() {
                return (maxX - minX) * (maxY - minY);
        }

        public Rectangle2D getBounds() {
                return new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
        }

        public long getDuration() {
                return getLastTimestamp() - getFirstTimestamp();
        }

        public PenSample getEnd() {
                return samples.get(samples.size() - 1);
        }

        public long getFirstTimestamp() {
                return samples.get(0).timestamp;
        }

        public Date getFirstTimestampAsDate() {
                return new Date(samples.get(0).timestamp);
        }

        public int[] getForceSamples() {
                int numSamples = getNumSamples();
                int[] f = new int[numSamples];
                for (int i = 0; i < numSamples; i++) {
                        f[i] = samples.get(i).force;
                }
                return f;
        }

        public long getLastTimestamp() {
                return samples.get(samples.size() - 1).timestamp;
        }

        public Date getLastTimestampAsDate() {
                return new Date(samples.get(samples.size() - 1).timestamp);
        }

        public double getMaxX() {
                return maxX;
        }

        public double getMaxY() {
                return maxY;
        }

        public double getMinX() {
                return minX;
        }

        public double getMinY() {
                return minY;
        }

        public int getNumSamples() {
                return samples.size();
        }

        public Units getReferenceUnit() {
                return referenceUnit;
        }

        public List<PenSample> getSamples() {
                return samples;
        }

        public PenSample getStart() {
                return samples.get(0);
        }

        public long[] getTimeSamples() {
                int numSamples = getNumSamples();
                long[] t = new long[numSamples];
                for (int i = 0; i < numSamples; i++) {
                        t[i] = samples.get(i).timestamp;
                }
                return t;
        }

        public double getWidth() {
                return strokeWidth;
        }

        public double[] getXSamples() {
                int numSamples = getNumSamples();
                double[] x = new double[numSamples];
                for (int i = 0; i < numSamples; i++) {
                        x[i] = samples.get(i).x;
                }
                return x;
        }

        public int[] getXSamplesAsInts() {
                int numSamples = getNumSamples();
                int[] xInts = new int[numSamples];
                for (int i = 0; i < numSamples; i++) {
                        xInts[i] = MathUtils.rint(samples.get(i).x);
                }
                return xInts;
        }

        public double[] getYSamples() {
                int numSamples = getNumSamples();
                double[] y = new double[numSamples];
                for (int i = 0; i < numSamples; i++) {
                        y[i] = samples.get(i).y;
                }
                return y;
        }

        public int[] getYSamplesAsInts() {
                int numSamples = getNumSamples();
                int[] yInts = new int[numSamples];
                for (int i = 0; i < numSamples; i++) {
                        yInts[i] = MathUtils.rint(samples.get(i).y);
                }
                return yInts;
        }

        public void setBounds(double minStrokeX, double minStrokeY, double maxStrokeX, double maxStrokeY) {
                minX = minStrokeX;
                minY = minStrokeY;
                maxX = maxStrokeX;
                maxY = maxStrokeY;
        }

        public void setMaxX(float mxX) {
                maxX = mxX;
        }

        public void setMaxY(float mxY) {
                maxY = mxY;
        }

        public void setMinX(float mnX) {
                minX = mnX;
        }

        public void setMinY(float mnY) {
                minY = mnY;
        }

        public void setSamples(List<PenSample> newSamples) {
                samples = newSamples;
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        public String toString() {
                return "InkStroke: Bounds [" + minX + ", " + minY + "  -->  " + maxX + ", " + maxY + "] "
                                + getNumSamples() + " Samples with timestamps from [" + getFirstTimestampAsDate() + " to "
                                + getLastTimestampAsDate() + "]";
        }

}

---