TiledPatternCoordinateConverter.java

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

import edu.stanford.hci.r3.pattern.TiledPattern;
import edu.stanford.hci.r3.units.PatternDots;
import edu.stanford.hci.r3.units.Percentage;
import edu.stanford.hci.r3.units.coordinates.PercentageCoordinates;
import edu.stanford.hci.r3.units.coordinates.StreamedPatternCoordinates;
import edu.stanford.hci.r3.util.DebugUtils;

public class TiledPatternCoordinateConverter implements PatternCoordinateConverter {

        private int bottomMostVoidSpaceInDots;

        private int dotsPerTileHorizontal;

        private int dotsPerTileVertical;

        private double maxX;

        private double maxY;

        private double numDotsHorizontalBetweenTiles;

        private double numDotsVerticalBetweenTiles;

        private int numTiles;

        private int numTilesAcross;

        private int numTilesDown;

        private double numTotalDotsAcross;

        private PatternDots numTotalDotsAcrossObj;

        private double numTotalDotsDown;

        private PatternDots numTotalDotsDownObj;

        private double originX;

        private double originY;

        private String regionName;

        private int rightMostVoidSpaceInDots;

        private int startingTile;

        private double tileHeightIncludingPadding;

        private double tileWidthIncludingPadding;

        public TiledPatternCoordinateConverter(String regionName) {
                this(regionName, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        }

        public TiledPatternCoordinateConverter(String theRegionName, //
                        double leftMostPatternXCoord, double topMostPatternYCoord, int dotsAcross, int dotsDown) {
                setRegionName(theRegionName);
                setStartingTile(0);
                setTileConfiguration(1, 1);
                setTileSizeInDots(dotsAcross, dotsDown);
                setOriginInDots(leftMostPatternXCoord, topMostPatternYCoord);
                setTotalSizeInDots(dotsAcross, dotsDown);
                setTileToTileOffsetInDots(0, 0);
        }

        public TiledPatternCoordinateConverter(String theRegionName, int startTile, int nTilesAcross,
                        int nTilesDown, int dotsPerTileHoriz, int dotsPerTileVert,
                        double numHorizDotsBetweenTiles, double numVertDotsBetweenTiles,
                        double leftMostPatternX, double topMostPatternY, double numDotsAcross,
                        double numDotsDown) {
                setRegionName(theRegionName);
                setStartingTile(startTile);
                setTileConfiguration(nTilesAcross, nTilesDown);
                setTileSizeInDots(dotsPerTileHoriz, dotsPerTileVert);
                setOriginInDots(leftMostPatternX, topMostPatternY);
                setTotalSizeInDots(numDotsAcross, numDotsDown);
                setTileToTileOffsetInDots(numHorizDotsBetweenTiles, numVertDotsBetweenTiles);
        }

        private void calculateCachedDimensions() {

                // set the maxX and tileHeight
                if (numTilesAcross == 1) {
                        tileWidthIncludingPadding = numTotalDotsAcross;
                        maxX = originX + numTotalDotsAcross;
                } else if (numDotsHorizontalBetweenTiles < dotsPerTileHorizontal) { // dX = 0
                        tileWidthIncludingPadding = dotsPerTileHorizontal;
                        maxX = originX + dotsPerTileHorizontal - rightMostVoidSpaceInDots; // only one
                        // horizontal
                        // tile
                } else { // bigger than the width
                        tileWidthIncludingPadding = numDotsHorizontalBetweenTiles;
                        maxX = originX + numDotsHorizontalBetweenTiles * numTiles - rightMostVoidSpaceInDots;
                }

                // set the maxY and tileHeight
                if (numTilesDown == 1) {
                        tileHeightIncludingPadding = numTotalDotsDown;
                        maxY = originY + numTotalDotsDown;
                } else if (numDotsVerticalBetweenTiles < dotsPerTileVertical) { // dY = 0
                        // only one vertical tile, like bnet's pattern
                        tileHeightIncludingPadding = dotsPerTileVertical;
                        maxY = originY + dotsPerTileVertical - bottomMostVoidSpaceInDots;
                } else { // bigger than the height
                        tileHeightIncludingPadding = numDotsVerticalBetweenTiles;
                        maxY = originY + numDotsVerticalBetweenTiles * numTiles - bottomMostVoidSpaceInDots;
                }

                // DebugUtils.println(regionName);
                // DebugUtils.println("Void Space in X: " + rightMostVoidSpaceInDots);
                // DebugUtils.println("Void Space in Y: " + bottomMostVoidSpaceInDots);
        }

        public boolean contains(final double xValPatternDots, final double yValPatternDots) {
                // has to be to the right of the leftmost border
                final boolean insideLeftBoundary = xValPatternDots >= originX;

                // has to be below the top border
                final boolean insideTopBoundary = yValPatternDots >= originY;

                // has to be to the left of the rightmost border
                final boolean insideRightBoundary = xValPatternDots < maxX;

                // has to be above the bottom border
                final boolean insideBottomBoundary = yValPatternDots < maxY;

                // has to NOT fall in between the gaps between pages...
                final boolean notInHorizontalGap = ((xValPatternDots - originX) % tileWidthIncludingPadding) < dotsPerTileHorizontal;
                final boolean notInVerticalGap = ((yValPatternDots - originY) % tileHeightIncludingPadding) < dotsPerTileVertical;

                return insideLeftBoundary && insideTopBoundary && insideRightBoundary
                                && insideBottomBoundary && notInHorizontalGap && notInVerticalGap;
        }

        public boolean contains(StreamedPatternCoordinates location) {
                final double xTestVal = location.getXVal();
                final double yTestVal = location.getYVal();

                return contains(xTestVal, yTestVal);
        }

        /*
         * (non-Javadoc)
         * 
         * @see edu.stanford.hci.r3.pattern.coordinates.conversion.PatternCoordinateConverter#getArea()
         */
        @Override
        public double getArea() {
                return numTotalDotsAcross * numTotalDotsDown;
        }

        public String getRegionName() {
                return regionName;
        }

        public PercentageCoordinates getRelativeLocation(StreamedPatternCoordinates coord) {

                final double xOffset = coord.getXVal() - originX;
                final double yOffset = coord.getYVal() - originY;

                final double xRelativeToTile = xOffset
                                - (getTileNumHorizontal(coord) * numDotsHorizontalBetweenTiles);
                final double yRelativeToTile = yOffset
                                - (getTileNumVertical(coord) * numDotsVerticalBetweenTiles);

                final int tileOffset = getTileNumber(coord) - startingTile;

                final int tileRow = tileOffset / numTilesAcross;
                final int tileCol = tileOffset % numTilesAcross;

                // how many dots are we in x & y
                final double totalDotsX = tileCol * dotsPerTileHorizontal + xRelativeToTile;
                final double totalDotsY = tileRow * dotsPerTileVertical + yRelativeToTile;

                final double pctX = totalDotsX / numTotalDotsAcross * 100;
                final double pctY = totalDotsY / numTotalDotsDown * 100;

                return new PercentageCoordinates( // 
                                new Percentage(pctX, numTotalDotsAcrossObj), // fraction of width
                                new Percentage(pctY, numTotalDotsDownObj)); // fraction of height
        }

        public int getTileNumber(StreamedPatternCoordinates coord) {
                if (!contains(coord)) {
                        return -1;
                }

                // using the x or y coordinate, determine the tile number
                // depending on the orientation of the pattern, these numbers may not be the same (i.e., one
                // of them may be zero while the other is not)
                final int tileNumHoriz = getTileNumHorizontal(coord);
                final int tileNumVert = getTileNumVertical(coord);

                return startingTile + Math.max(tileNumHoriz, tileNumVert);
        }

        private int getTileNumHorizontal(StreamedPatternCoordinates coord) {
                return (int) Math.floor((coord.getXVal() - originX) / tileWidthIncludingPadding);
        }

        private int getTileNumVertical(StreamedPatternCoordinates coord) {
                return (int) Math.floor((coord.getYVal() - originY) / tileHeightIncludingPadding);
        }

        private void setNumDotsFromBottomMostTilesThatAreNotIncluded(int numDots) {
                bottomMostVoidSpaceInDots = numDots;
                calculateCachedDimensions();
        }

        private void setNumDotsFromRightMostTilesThatAreNotIncluded(int numDots) {
                rightMostVoidSpaceInDots = numDots;
                calculateCachedDimensions();
        }

        public void setOriginInDots(double leftMostPatternX, double topMostPatternY) {
                originX = leftMostPatternX;
                originY = topMostPatternY;

                // must update some internal state
                calculateCachedDimensions();
        }

        public void setPatternInformationByReadingItFrom(TiledPattern p) {
                final int voidX = p.getNumDotsXPerFullTile() - p.getNumDotsXFromRightMostTiles();
                final int voidY = p.getNumDotsYPerFullTile() - p.getNumDotsYFromBottomMostTiles();

                setNumDotsFromRightMostTilesThatAreNotIncluded(voidX);
                setNumDotsFromBottomMostTilesThatAreNotIncluded(voidY);

                setOriginInDots(p.getOriginXInDots(), p.getOriginYInDots());
                setStartingTile(p.getInitialPatternFileNumber());
                setTileConfiguration(p.getNumTilesX(), p.getNumTilesY());
                setTileSizeInDots(p.getNumDotsXPerFullTile(), p.getNumDotsYPerFullTile());
                setTileToTileOffsetInDots(p.getNumHorizDotsBetweenTiles(), p.getNumVertDotsBetweenTiles());
                setTotalSizeInDots(p.getNumTotalColumns(), p.getNumTotalRows());

                DebugUtils.println("");
                System.out.println("=========================");
                System.out.println(p);
                System.out.println(this);
                System.out.println("=========================");

        }

        public void setRegionName(String rName) {
                regionName = rName;
        }

        public void setStartingTile(int startTile) {
                startingTile = startTile;
        }

        public void setTileConfiguration(int nTilesAcross, int nTilesDown) {
                numTilesAcross = nTilesAcross;
                numTilesDown = nTilesDown;
                numTiles = numTilesAcross * numTilesDown;
        }

        public void setTileSizeInDots(int dotsPerTileHoriz, int dotsPerTileVert) {
                dotsPerTileHorizontal = dotsPerTileHoriz;
                dotsPerTileVertical = dotsPerTileVert;

                // must update some internal state
                calculateCachedDimensions();
        }

        public void setTileToTileOffsetInDots(double numHorizDotsBetweenTiles,
                        double numVertDotsBetweenTiles) {
                // what is the x offset between the origins of two adjacent tiles?
                // this is the width of a tile, plus a padding that anoto creates when you use the FDK to
                // generate pattern
                numDotsHorizontalBetweenTiles = numHorizDotsBetweenTiles;
                // what is the y offset between the origins of two adjacent tiles?
                // note that in the BNet pattern space, the y offset is 0
                numDotsVerticalBetweenTiles = numVertDotsBetweenTiles;

                // must update some internal state
                calculateCachedDimensions();
        }

        public void setTotalSizeInDots(double numDotsAcross, double numDotsDown) {
                // how wide and tall is the whole region?
                numTotalDotsAcross = numDotsAcross;
                numTotalDotsDown = numDotsDown;

                // save this for later calculations
                numTotalDotsAcrossObj = new PatternDots(numTotalDotsAcross);
                numTotalDotsDownObj = new PatternDots(numTotalDotsDown);

                calculateCachedDimensions();
        }

        public String toString() {
                return "TiledPatternCoordinateConverter {" + "x=" + originX + ", y=" + originY + " w="
                                + numTotalDotsAcrossObj + ", h=" + numTotalDotsDownObj + "}";
        }
}

---