InkUtils.java

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

import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.tools.develop.inkapibrowser.HideFromFlash;
import edu.stanford.hci.r3.util.DebugUtils;

public class InkUtils {

        public static List<Ink> clusterStrokes(List<InkStroke> strokes, final double margin) {

                class Cluster extends Ink {
                        private Rectangle2D bounds;

                        void add(InkStroke stroke) {
                                super.addStroke(stroke);
                                Rectangle2D strokeBounds = expand(stroke.getBounds());
                                if (bounds == null)
                                        bounds = strokeBounds;
                                else
                                        bounds.add(strokeBounds);
                        }

                        private Rectangle2D expand(Rectangle2D r) {
                                double dx = r.getWidth() * margin / 2;
                                double dy = r.getHeight() * margin / 2;
                                return new Rectangle2D.Double(r.getX() - dx, r.getY() - dy, r.getWidth() + dx * 2, r
                                                .getHeight()
                                                + dy * 2);
                        }

                        boolean matches(InkStroke stroke) {
                                return expand(stroke.getBounds()).intersects(bounds);
                        }
                }

                List<Cluster> clusters = new ArrayList<Cluster>();

                for (InkStroke stroke : strokes) {
                        Cluster foundCluster = null;
                        for (Cluster cluster : clusters) {
                                if (cluster.matches(stroke)) {
                                        foundCluster = cluster;
                                        break;
                                }
                        }
                        if (foundCluster == null) {
                                foundCluster = new Cluster();
                                clusters.add(foundCluster);
                        }
                        foundCluster.add(stroke);
                }

                return new ArrayList<Ink>(clusters);
        }

        public static List<InkStroke> getAllStrokesContainedWithin(List<Ink> inkWell, InkStroke container) {

                // calculate the bounds of the container stroke
                Rectangle2D bounds = container.getBounds();

                // return any stroke that falls completely within these bounds
                // do not include the original container!
                List<InkStroke> matchingStrokes = new ArrayList<InkStroke>();
                for (Ink ink : inkWell) {
                        List<InkStroke> strokes = ink.getStrokes();
                        for (InkStroke stroke : strokes) {
                                if (bounds.contains(stroke.getBounds()) && !container.equals(stroke)) {
                                        // the stroke is completely inside the containing stroke
                                        matchingStrokes.add(stroke);
                                }
                        }
                }
                return matchingStrokes;
        }

        public static List<InkStroke> getAllStrokesOutside(List<Ink> inkWell, InkStroke container) {

                // calculate the bounds of the container stroke
                Rectangle2D bounds = container.getBounds();

                // return any stroke that falls completely outside these bounds
                List<InkStroke> matchingStrokes = new ArrayList<InkStroke>();
                for (Ink ink : inkWell) {
                        List<InkStroke> strokes = ink.getStrokes();
                        for (InkStroke stroke : strokes) {
                                if (!bounds.intersects(stroke.getBounds())) {
                                        // the stroke is completely outside the containing stroke
                                        matchingStrokes.add(stroke);
                                }
                        }
                }
                return matchingStrokes;
        }

        @HideFromFlash()
        public static List<Method> getExposedMethods() {
                Method[] methods = InkUtils.class.getMethods();
                Class<InkUtils> c = InkUtils.class;
                Class<?> s = c.getSuperclass();

                List<Method> methodsToReturn = new ArrayList<Method>();

                for (Method m : methods) {
                        Class<?> declaringClass = m.getDeclaringClass();
                        if (c.equals(declaringClass)) {
                                // not marked as hidden? and...
                                // TODO with a named shortcut?
                                if (m.isAnnotationPresent(HideFromFlash.class)) {
                                        // do nothing for hidden methods
                                } else {
                                        // DebugUtils.println(m.getName());
                                        methodsToReturn.add(m);
                                }
                        }
                }
                return methodsToReturn;
        }

        public static Ink getInkNearPoint(List<Ink> inkWell, Point2D point, double range) {

                Rectangle2D pointRange = new Rectangle2D.Double(point.getX() - range, point.getY() - range,
                                range * 2, range * 2);
                for (Ink ink : inkWell)
                        for (InkStroke stroke : ink.getStrokes())
                                if (pointRange.intersects(stroke.getBounds()))
                                        return ink;
                return null;
        }

        public static double getMaxDistanceBetweenSamples(InkStroke stroke) {
                List<PenSample> samples = stroke.getSamples();
                PenSample currSample = samples.get(0);
                double maxDistance = Double.MIN_VALUE;
                for (PenSample s : samples) {
                        maxDistance = Math.max(s.getDistanceFrom(currSample), maxDistance);
                        currSample = s;
                }
                return maxDistance;
        }

        public static List<InkStroke> getStrokesPartlyOutside(List<Ink> inkWell, InkStroke container) {

                // calculate the bounds of the container stroke
                Rectangle2D bounds = container.getBounds();

                // return any stroke that overlaps the container but is not contained
                // by it
                List<InkStroke> matchingStrokes = new ArrayList<InkStroke>();
                for (Ink ink : inkWell) {
                        List<InkStroke> strokes = ink.getStrokes();
                        for (InkStroke stroke : strokes) {
                                Rectangle2D strokeBounds = stroke.getBounds();
                                if (bounds.intersects(strokeBounds) && !bounds.contains(strokeBounds)) {
                                        // the stroke is completely outside the containing stroke
                                        matchingStrokes.add(stroke);
                                }
                        }
                }
                return matchingStrokes;
        }

        public static InkStroke getStrokeWithLargestArea(List<Ink> inkWell) {
                InkStroke biggestStroke = null;
                double maxArea = Double.MIN_VALUE;

                for (Ink ink : inkWell) {
                        List<InkStroke> strokes = ink.getStrokes();
                        for (InkStroke stroke : strokes) {

                                double area = stroke.getArea();
                                if (area > maxArea) {
                                        biggestStroke = stroke;
                                        maxArea = area;
                                }
                        }
                }

                DebugUtils.println(biggestStroke);
                return biggestStroke;
        }

        public static Ink getStrokeWithMostSamples(Ink ink) {
                List<InkStroke> matchingStrokes = new ArrayList<InkStroke>();
                List<InkStroke> strokes = ink.getStrokes();

                int maxNumSamples = 0;
                InkStroke longestStroke = null;

                for (InkStroke stroke : strokes) {
                        int numSamples = stroke.getNumSamples();
                        DebugUtils.println(numSamples);
                        if (numSamples > maxNumSamples) {
                                DebugUtils.println("Longest");
                                longestStroke = stroke;
                                maxNumSamples = numSamples;
                        }
                }
                if (longestStroke != null) {
                        matchingStrokes.add(longestStroke);
                }
                return new Ink(matchingStrokes);
        }

        @HideFromFlash
        public static void main(String[] args) {
                InkUtils.getExposedMethods();
        }
}

---