Ink.java

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

import java.awt.Color;
import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.swing.filechooser.FileSystemView;

import edu.stanford.hci.r3.pattern.coordinates.PageAddress;
import edu.stanford.hci.r3.render.ink.InkRenderer;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.MathUtils;
import edu.stanford.hci.r3.util.files.FileUtils;

public class Ink {

        public enum InkSource {
                BATCHED, STREAMED, UNKNOWN
        }

        private static final Color DEFAULT_DARK_INK_COLOR = new Color(0, 0, 0, 230);

        private Color color = DEFAULT_DARK_INK_COLOR;

        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 String name = "Ink";

        private PageAddress pageAddress;

        private InkSource sourceType = InkSource.UNKNOWN;

        private List<InkStroke> strokes;

        public Ink() {
                this(new ArrayList<InkStroke>());
        }

        public Ink(File xmlFile) {
                this(); // empty list of strokes
                loadFromXMLFile(xmlFile);
        }

        public Ink(List<InkStroke> theStrokes) {
                strokes = theStrokes;

                for (InkStroke s : theStrokes) {
                        updateMinAndMax(s);
                }
        }

        public void addStroke(InkStroke s) {
                strokes.add(s);
                updateMinAndMax(s);
        }

        public String getAsXML() {
                return getAsXML(true);
        }

        public String getAsXML(boolean useSeparatorLines) {
                final String separator = useSeparatorLines ? "\n" : "";

                StringBuilder sb = new StringBuilder();
                sb.append(getOpenTagXML() + separator);
                sb.append(getInnerXML(useSeparatorLines) + separator);
                sb.append("</ink>");
                return sb.toString();
        }

        public Color getColor() {
                return color;
        }

        public String getInnerXML() {
                return getInnerXML(false);
        }

        public String getInnerXML(boolean useSeparatorLines) {
                final String separator = useSeparatorLines ? "\n" : "";
                StringBuilder sb = new StringBuilder();
                for (InkStroke s : strokes) {
                        sb.append("<stroke begin=\"" + s.getFirstTimestamp() + "\" end=\""
                                        + s.getLastTimestamp() + "\">" + separator);
                        double[] x = s.getXSamples();
                        double[] y = s.getYSamples();
                        int[] f = s.getForceSamples();
                        long[] ts = s.getTimeSamples();
                        for (int i = 0; i < x.length; i++) {
                                sb.append("<p x=\"" + x[i] + "\" y=\"" + y[i] + "\" f=\"" + f[i] + "\" t=\""
                                                + ts[i] + "\"/>");
                        }
                        sb.append("</stroke>" + separator);
                }
                return sb.toString();
        }

        public double getMaxX() {
                return maxX;
        }

        public double getMaxY() {
                return maxY;
        }

        public double getMinX() {
                return minX;
        }

        public double getMinY() {
                return minY;
        }

        public String getName() {
                return name;
        }

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

        private String getOpenTagXML() {
                if (pageAddress == null) {
                        return "<ink>";
                } else {
                        return "<ink address=\"" + pageAddress.toString() + "\">";
                }
        }

        public InkRenderer getRenderer() {
                return new InkRenderer(this);
        }

        public PageAddress getSourcePageAddress() {
                return pageAddress;
        }

        public InkSource getSourceType() {
                return sourceType;
        }

        public List<InkStroke> getStrokes() {
                return strokes;
        }

        public void loadFromXMLFile(File xmlFileSource) {
                new InkXMLParser(this).parse(xmlFileSource);
        }

        public void removeStroke(InkStroke s) {
                strokes.remove(s);
        }

        public File renderToJPEGFile() {
                File homeDir = FileSystemView.getFileSystemView().getHomeDirectory();
                // DebugUtils.println(homeDir);
                File destFile = new File(homeDir, getName() + ".jpg");
                // DebugUtils.println(destFile);
                new InkRenderer(this).renderToJPEGRecentered(destFile);
                return destFile;
        }

        public void resetColor() {
                setColor(DEFAULT_DARK_INK_COLOR);
        }

        public void saveToXMLFile(File xmlFileDest) {
                FileUtils.writeStringToFile(getAsXML(true), xmlFileDest);
        }

        public void setColor(Color c) {
                color = c;
        }

        public void setName(String theName) {
                name = theName;
        }

        public void setSourcePageAddress(PageAddress address) {
                setSourceType(InkSource.BATCHED);
                pageAddress = address;
        }

        public void setSourcePageAddress(String pageAddrString) {
                setSourcePageAddress(new PageAddress(pageAddrString));
        }

        public void setSourceType(InkSource src) {
                sourceType = src;
        }

        private void updateMinAndMax(InkStroke s) {
                // update maxs and mins
                minX = Math.min(s.getMinX(), minX);
                minY = Math.min(s.getMinY(), minY);
                maxX = Math.max(s.getMaxX(), maxX);
                maxY = Math.max(s.getMaxY(), maxY);
        }
}

---