PatternLocationToSheetLocationMapping.java

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

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.paper.Region;
import edu.stanford.hci.r3.paper.Sheet;
import edu.stanford.hci.r3.pattern.coordinates.conversion.PatternCoordinateConverter;
import edu.stanford.hci.r3.pattern.coordinates.conversion.TiledPatternCoordinateConverter;
import edu.stanford.hci.r3.pen.PenSample;
import edu.stanford.hci.r3.units.PatternDots;
import edu.stanford.hci.r3.units.coordinates.PercentageCoordinates;
import edu.stanford.hci.r3.units.coordinates.StreamedPatternCoordinates;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.MathUtils;
import edu.stanford.hci.r3.util.files.FileUtils;

public class PatternLocationToSheetLocationMapping {

        // files end with .patternInfo.xml
        private static final String[] PATTERN_INFO_EXTENSION_FILTER = new String[] { "patternInfo.xml" };

        private Map<Region, PatternCoordinateConverter> regionToPatternBounds = new HashMap<Region, PatternCoordinateConverter>();

        private Sheet sheet;

        public PatternLocationToSheetLocationMapping(Sheet s) {
                sheet = s;
                final List<Region> regions = s.getRegions();
                warnIfThereAreNoRegions(regions);
                initializeMap(regions);
                loadConfigurationFromAutomaticallyDiscoveredXMLFiles();
        }

        public PatternLocationToSheetLocationMapping(Sheet s, File patternInfoFile) {
                sheet = s;
                final List<Region> regions = s.getRegions();
                warnIfThereAreNoRegions(regions);
                initializeMap(regions);
                loadConfigurationFromXML(patternInfoFile);
        }

        public PatternCoordinateConverter getCoordinateConverterForSample(PenSample sample) {
                for (Region r : regionToPatternBounds.keySet()) {
                        PatternCoordinateConverter converter = regionToPatternBounds.get(r);
                        final StreamedPatternCoordinates coord = new StreamedPatternCoordinates(sample);
                        if (converter.contains(coord)) {
                                // DebugUtils.println("Sample is on: " + r.getName());

                                // where are we on this region?
                                final PercentageCoordinates relativeLocation = converter.getRelativeLocation(coord);

                                // currently, this is a FALLBACK HACK to check whether we are actually outside the
                                // region later on, we must fix this and catch it earlier in the process
                                if (relativeLocation.getPercentageInXDirection() > 100
                                                || relativeLocation.getPercentageInYDirection() > 100) {
                                        DebugUtils.println("FALLBACK HACK. It's actually outside the bounds. "
                                                        + "Going on to check the next region...");
                                        continue;
                                } else {
                                        return converter;
                                }
                        }
                }
                return null; // couldn't find any
        }

        public PatternCoordinateConverter getPatternBoundsOfRegion(Region r) {
                DebugUtils.println(regionToPatternBounds.size() + " " + r.getName() + " "
                                + regionToPatternBounds);

                return regionToPatternBounds.get(r);
        }

        public Map<Region, PatternCoordinateConverter> getRegionToPatternMapping() {
                return regionToPatternBounds;
        }

        public Sheet getSheet() {
                return sheet;
        }

        public void initializeMap(List<Region> regions) {
                regionToPatternBounds.clear();
                for (final Region r : regions) {
                        if (r.isActive()) {
                                // put in an empty one for now. It should be updated later... otherwise,
                                // this active region will not be accessible by the end user
                                // note: I introduced a bug here a while back, by changing the name I gave to the
                                // TiledPatternCoordinateConverter (_UninitializedMapping). Watch out if you want to
                                // customize this name!
                                regionToPatternBounds.put(r, new TiledPatternCoordinateConverter(r.getName()));
                        }
                }
        }

        private void loadConfigurationFromAutomaticallyDiscoveredXMLFiles() {
                // check to see if the pattern configuration file exists.
                // if it does, load it automatically...
                final Set<File> configurationPaths = sheet.getConfigurationPaths();
                if (configurationPaths.size() == 0) {
                        DebugUtils.println("This Sheet does not have any pattern configuration paths. "
                                        + "Either add one so that we can automatically look for *.patternInfo.xml "
                                        + "files, or add patternInfo files explicitly.");
                        return;
                }

                DebugUtils.println("This Sheet has configuration paths for *.patternInfo.xml files.");

                for (File path : configurationPaths) {
                        // System.out.println(path);
                        List<File> patternInfoFiles = FileUtils.listVisibleFiles(path,
                                        PATTERN_INFO_EXTENSION_FILTER);
                        // System.out.println(patternInfoFiles.size());
                        for (File f : patternInfoFiles) {
                                DebugUtils.println("Trying to automatically load " + f.getName());
                                loadConfigurationFromXML(f);
                        }
                }
        }

        @SuppressWarnings("unchecked")
        public void loadConfigurationFromXML(File xmlFile) {
                // for each region, there should be a specification of the pattern information
                final HashMap<RegionID, PatternCoordinateConverter> regionIDToPattern = (HashMap<RegionID, PatternCoordinateConverter>) PaperToolkit
                                .fromXML(xmlFile);
                for (Region r : regionToPatternBounds.keySet()) {
                        final RegionID xmlKey = new RegionID(r);
                        // System.out.println("Found Key: " + regionIDToPattern.containsKey(xmlKey) + " for " +
                        // r.getName());

                        // loads the information into our map
                        if (regionIDToPattern.containsKey(xmlKey)) {
                                DebugUtils.println("Loaded Pattern Configuration for " + xmlKey);
                                regionToPatternBounds.put(r, regionIDToPattern.get(xmlKey));
                        }
                }
        }

        public void printMapping() {
                System.out.println(this);
        }

        public void saveConfigurationToXML(File xmlFile) {
                try {
                        // create a new map that goes from name+origin to pattern bounds mapping
                        // only save active regions... because we don't render pattern for nonactive regions
                        final HashMap<RegionID, PatternCoordinateConverter> regionIDToPattern = new HashMap<RegionID, PatternCoordinateConverter>();
                        final Set<Region> regions = regionToPatternBounds.keySet();
                        for (Region r : regions) {
                                if (!r.isActive()) {
                                        continue;
                                }
                                final RegionID rid = new RegionID(r);
                                regionIDToPattern.put(rid, regionToPatternBounds.get(r));
                        }
                        if (xmlFile.exists()) {
                                DebugUtils.println("Overwriting XML File: " + xmlFile.getName());
                                xmlFile.delete();
                        }
                        PaperToolkit.toXML(regionIDToPattern, new FileOutputStream(xmlFile));
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                }
        }

        public void setPatternInformationOfRegion(Region r, PatternCoordinateConverter coordinateInfo) {
                if (regionToPatternBounds.containsKey(r) || sheet.containsRegion(r)) {
                        // updating an already-known region OR
                        // adding a new region (probably added to the sheet after this object was constructed)
                        regionToPatternBounds.put(r, coordinateInfo);
                } else {
                        System.err.println("PatternLocationToSheetLocationMapping.java: Region unknown. "
                                        + "Please add it to the sheet before updating this mapping.");
                }
        }

        public void setPatternInformationOfRegion(Region region, //
                        PatternDots x, PatternDots y, PatternDots width, PatternDots height) {
                setPatternInformationOfRegion(region, new TiledPatternCoordinateConverter(region.getName(),
                                x.getValue(), y.getValue(), //
                                MathUtils.rint(width.getValue()), MathUtils.rint(height.getValue())));
        }

        public void setSheet(Sheet s) {
                sheet = s;
        }

        public String toString() {
                final StringBuilder sb = new StringBuilder();
                for (final Region r : regionToPatternBounds.keySet()) {
                        sb.append(r.getName() + " --> ");
                        final PatternCoordinateConverter bounds = regionToPatternBounds.get(r);
                        sb.append(bounds + ", ");
                }
                String string = sb.toString();
                if (string.length() > 2) {
                        return string.substring(0, string.length() - 2); // chop off the last ", "
                } else {
                        return string;
                }
        }

        private void warnIfThereAreNoRegions(final List<Region> regions) {
                // at this point, the sheet has to have regions...
                // for now, warn, if there are no regions
                if (regions.size() == 0) {
                        DebugUtils.println("There aren't any regions. Did you perhaps add the "
                                        + "regions _after_ you added the sheet to the application?");
                }
        }
}

---