CalibrationCaptureApp.java

package edu.stanford.hci.r3.pattern.calibrate;

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

import edu.stanford.hci.r3.Application;
import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.pen.Pen;
import edu.stanford.hci.r3.pen.batch.BatchedEventHandler;
import edu.stanford.hci.r3.pen.ink.Ink;
import edu.stanford.hci.r3.pen.ink.InkStroke;
import edu.stanford.hci.r3.pen.streaming.listeners.PenListener;
import edu.stanford.hci.r3.pen.streaming.listeners.PenStrokeListener;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.MathUtils;
import edu.stanford.hci.r3.util.WindowUtils;
import edu.stanford.hci.r3.util.files.FileUtils;

public class CalibrationCaptureApp {

        public static void main(String[] args) {
                new CalibrationCaptureApp();
        }

        private Application app;

        private BatchedEventHandler beh;

        private CalibrationEngine calibrate = new CalibrationEngine();

        private JButton calibrateButton;

        private Ink currStreamedInk;

        private JFrame frame;

        private PenListener listener;

        private JPanel mainPanel;

        private Pen pen;

        private Ink savedBatchedInk;

        private Ink savedStreamedInk;

        private JButton saveStrokesButton;

        private long streamedStrokesFileName;

        private JLabel streamedStrokesInfoLabel;

        private PaperToolkit toolkit;

        public CalibrationCaptureApp() {
                PaperToolkit.initializeLookAndFeel();
                setupGUI();

                app = new Application("Calibration");
                app.addPenInput(getPen());
                app.addBatchEventHandler(getBatchedEventHandler());
                toolkit = new PaperToolkit(true, false, false);
                toolkit.startApplication(app);
        }

        private void alignStreamedAndBatchedStrokes() {
                calibrate.alignInkStrokes(savedStreamedInk, savedBatchedInk);
        }

        private BatchedEventHandler getBatchedEventHandler() {
                if (beh == null) {
                        beh = new BatchedEventHandler("Calibration") {
                                @Override
                                public void inkArrived(Ink inkOnThisPage) {
                                        saveBatchedStrokes(inkOnThisPage);
                                }

                        };
                }
                return beh;
        }

        private Component getCalibrateButton() {
                if (calibrateButton == null) {
                        calibrateButton = new JButton("Calibrate (Align Streamed & Batched Strokes)");
                        calibrateButton.setAlignmentX(Component.CENTER_ALIGNMENT);
                        calibrateButton.addActionListener(new ActionListener() {
                                public void actionPerformed(ActionEvent e) {
                                        alignStreamedAndBatchedStrokes();
                                }
                        });
                }
                return calibrateButton;
        }

        private Component getPanel() {
                if (mainPanel == null) {
                        mainPanel = new JPanel();
                        mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));
                        mainPanel.setBorder(BorderFactory.createEmptyBorder(10, 20, 10, 20));
                        mainPanel.add(getSaveStreamedStrokesButton());
                        mainPanel.add(Box.createVerticalStrut(10));
                        mainPanel.add(getStreamedStrokesInfoLabel());
                        mainPanel.add(Box.createVerticalStrut(10));
                        mainPanel.add(getCalibrateButton());
                }
                return mainPanel;
        }

        private Pen getPen() {
                if (pen == null) {
                        pen = new Pen();
                        pen.addLivePenListener(getPenListener());
                }
                return pen;
        }

        private PenListener getPenListener() {
                if (listener == null) {
                        listener = new PenStrokeListener() {
                                @Override
                                public void penStroke(InkStroke stroke) {
                                        if (currStreamedInk == null) {
                                                currStreamedInk = new Ink();
                                        }

                                        currStreamedInk.addStroke(stroke);
                                        DebugUtils.println(currStreamedInk.getNumStrokes() + " strokes collected.");

                                        final double[] samplesX = stroke.getXSamples();
                                        final double[] samplesY = stroke.getYSamples();
                                        DebugUtils.println("STDEV X: " + MathUtils.standardDeviation(samplesX));
                                        DebugUtils.println("STDEV Y: " + MathUtils.standardDeviation(samplesY));
                                }
                        };
                }
                return listener;
        }

        private Component getSaveStreamedStrokesButton() {
                if (saveStrokesButton == null) {
                        saveStrokesButton = new JButton("Save Streamed Strokes");
                        saveStrokesButton.setAlignmentX(Component.CENTER_ALIGNMENT);
                        saveStrokesButton.addActionListener(new ActionListener() {
                                public void actionPerformed(ActionEvent arg0) {
                                        saveStreamedStrokes();
                                }

                        });
                }
                return saveStrokesButton;
        }

        private Component getStreamedStrokesInfoLabel() {
                if (streamedStrokesInfoLabel == null) {
                        streamedStrokesInfoLabel = new JLabel("No Saved Strokes");
                        streamedStrokesInfoLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
                }
                return streamedStrokesInfoLabel;
        }

        private void saveBatchedStrokes(Ink inkOnThisPage) {
                savedBatchedInk = inkOnThisPage;
                FileUtils.writeStringToFile(inkOnThisPage.getAsXML(), new File("data/calibration/"
                                + streamedStrokesFileName + ".batched.xml"));
        }

        private void saveStreamedStrokes() {
                savedStreamedInk = currStreamedInk;
                currStreamedInk = null;
                streamedStrokesFileName = System.currentTimeMillis();
                FileUtils.writeStringToFile(savedStreamedInk.getAsXML(), new File("data/calibration/"
                                + streamedStrokesFileName + ".streamed.xml"));
                streamedStrokesInfoLabel.setText(savedStreamedInk.getNumStrokes() + " strokes saved.");
        }

        private void setupGUI() {
                frame = new JFrame("Pen Calibration");
                frame.add(getPanel());
                frame.pack();
                frame.setLocation(WindowUtils.getWindowOrigin(frame, WindowUtils.DESKTOP_CENTER));
                frame.setVisible(true);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
}

---