CaptureApplication.java

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

import java.io.File;
import java.util.List;

import edu.stanford.hci.r3.Application;
import edu.stanford.hci.r3.events.handlers.HandwritingRecognizer;
import edu.stanford.hci.r3.events.handlers.InkCollector;
import edu.stanford.hci.r3.paper.Region;
import edu.stanford.hci.r3.paper.Sheet;
import edu.stanford.hci.r3.pattern.coordinates.PatternLocationToSheetLocationMapping;
import edu.stanford.hci.r3.pen.Pen;
import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.pen.streaming.PenAdapter;
import edu.stanford.hci.r3.pen.streaming.listeners.PenListener;
import edu.stanford.hci.r3.units.PatternDots;
import edu.stanford.hci.r3.util.DebugUtils;

public class CaptureApplication extends Application {

        private PenSample anchorPointBottomRight;

        private PenSample anchorPointTopLeft;

        private HandwritingCaptureDebugger gui;

        private HandwritingRecognizer handwritingRecognizer;

        private InkCollector inkCollector;

        private long lastTimeNewInkArrived = 0;

        private Sheet mainSheet;

        private Pen pen;

        private Thread recognizeThread = new Thread(new Runnable() {
                public void run() {
                        while (true) {
                                try {
                                        wait();

                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        });

        public CaptureApplication(HandwritingCaptureDebugger debugger) {
                super("Handwriting Capture");
                addPenInput(getPen());
                gui = debugger;
        }

        public void addCalibrationHandler() {
                anchorPointTopLeft = null;
                anchorPointBottomRight = null;

                final Pen pen = getPen();
                pen.addLivePenListener(new PenAdapter() {
                        public void penUp(PenSample sample) {
                                if (anchorPointTopLeft == null) {
                                        anchorPointTopLeft = sample;
                                        DebugUtils.println("Top Left Point is now set to " + anchorPointTopLeft);
                                        gui.showTopLeftPointConfirmation();
                                } else if (anchorPointBottomRight == null) {
                                        anchorPointBottomRight = sample;
                                        DebugUtils
                                                        .println("Bottom Right Point is now set to " + anchorPointBottomRight);
                                        gui.showBottomRightPointConfirmation();
                                        scaleInkPanelToFit();
                                        addOneSheetAndOneRegionForHandwritingCapture();

                                        // after setting the bottom right point, we should remove this pen listener...
                                        final PenListener listener = this;
                                        // We must modify the listeners from an external thread, as we are
                                        // currently iterating through it
                                        // This will happen after we have released the lock
                                        new Thread(new Runnable() {
                                                public void run() {
                                                        pen.removeLivePenListener(listener);
                                                }
                                        }).start();
                                }
                        }

                });
        }

        private void addOneSheetAndOneRegionForHandwritingCapture() {
                // ask the event engine to remove our sheet and our mappings, if they exist
                if (mainSheet != null) {
                        DebugUtils.println("Removing old region...");

                        // remove the sheet from this application
                        removeSheet(mainSheet);
                        mainSheet = null;
                }

                // add a new sheet
                final Sheet sheet = getMainSheet();
                final Region region = setupCaptureRegion();
                sheet.addRegion(region);

                // determine the bounds of the region in pattern space
                // this information was provided by the user
                final double tlX = anchorPointTopLeft.getX();
                final double tlY = anchorPointTopLeft.getY();
                final double brX = anchorPointBottomRight.getX();
                final double brY = anchorPointBottomRight.getY();
                final double width = brX - tlX;
                final double height = brY - tlY;

                // create this custom mapping object
                final PatternLocationToSheetLocationMapping mapping = new PatternLocationToSheetLocationMapping(
                                sheet);

                // tie the pattern bounds to this region object
                mapping.setPatternInformationOfRegion(region, //
                                new PatternDots(tlX), new PatternDots(tlY), // 
                                new PatternDots(width), new PatternDots(height));

                addSheet(sheet, mapping);
                // DebugUtils.println(mapping);
        }

        public void clearInk() {
                if (inkCollector != null) {
                        inkCollector.clear();
                }
                if (handwritingRecognizer != null) {
                        handwritingRecognizer.clear();
                }
        }

        private Sheet getMainSheet() {
                if (mainSheet == null) {
                        mainSheet = new Sheet(8.5, 11);
                }
                return mainSheet;
        }

        public Pen getPen() {
                if (pen == null) {
                        pen = new Pen("Main Pen");
                }
                return pen;
        }

        public void retrieveAlternatives() {
                // top ten list
                final List<String> topTen = handwritingRecognizer.recognizeHandwritingWithAlternatives();
                gui.setAlternatives(topTen);
        }

        public void saveInkToDisk() {
                File file = new File(System.currentTimeMillis() + "_ink.xml");
                DebugUtils.println("Saving as: " + file.getAbsolutePath());
                inkCollector.saveInkToXMLFile(file);
        }

        private void scaleInkPanelToFit() {
                final double width = anchorPointBottomRight.x - anchorPointTopLeft.x;
                final double height = anchorPointBottomRight.y - anchorPointTopLeft.y;
                double newScale = 1.0;
                if (width > height) {
                        // constrain to the width
                        final PatternDots numDots = new PatternDots(width);
                        final double definedWidth = numDots.getValueInPixels();
                        final double guiWidth = gui.getInkPanel().getSize().getWidth();
                        newScale = guiWidth / definedWidth;
                } else {
                        // constrain to the height
                        final PatternDots numDots = new PatternDots(height);
                        final double definedHeight = numDots.getValueInPixels();
                        final double guiHeight = gui.getInkPanel().getSize().getHeight();
                        newScale = guiHeight / definedHeight;
                }
                // DebugUtils.println("New Scale: " + newScale);
                gui.getInkPanel().setScale(newScale);
        }

        private Region setupCaptureRegion() {
                // the actual "physical" size of this region doesn't matter, as we never print it!
                final Region region = new Region("Handwriting Capture", 0, 0, 1, 1);

                // for displaying ink
                inkCollector = new InkCollector() {
                        @Override
                        public void contentArrived() {
                                // DebugUtils.println(getInk().getNumStrokes());
                                gui.getInkPanel().addInk(getNewInkOnly());
                        }
                };

                // for recognizing the strokes
                handwritingRecognizer = new HandwritingRecognizer() {

                        @Override
                        public void contentArrived() {
                                lastTimeNewInkArrived = System.currentTimeMillis();

                                String text = recognizeHandwriting();
                                DebugUtils.println("Handwritten Content: " + text);
                                gui.setInfoText(text);
                                // gui.setAlternatives(topTen);
                        }
                };

                region.addEventHandler(inkCollector);
                region.addEventHandler(handwritingRecognizer);
                return region;
        }
}

---