TiledPattern.java

package edu.stanford.hci.r3.pattern;

import edu.stanford.hci.r3.units.PatternDots;
import edu.stanford.hci.r3.units.coordinates.StreamedPatternCoordinates;
import edu.stanford.hci.r3.util.DebugUtils;

public class TiledPattern {

        private int initialDotXOffset;

        private int initialDotYOffset;

        private int initialPatternFileNum = 0;

        private int lastPatternFileUsed;

        private int numDotsXPerFullTile;

        private int numDotsXRightMost;

        private int numDotsYBottomMost;

        private int numDotsYPerFullTile;

        private int numTilesX;

        private int numTilesY;

        private int numTotalColumns;

        private int numTotalRows;

        private StringBuilder[] pattern;

        private StreamedPatternCoordinates patternCoordinateOfOrigin;

        private PatternPackage patternPackage;

        public TiledPattern(PatternPackage thePatternPackage, // where to get pattern from
                        int initialPatternFileN, int initialDotHorizOffset, int initialDotVertOffset, //
                        int numTilesNeededX, int numTilesNeededY, // how many we'll need
                        int numDotsXFromRightMostTiles, int numDotsYFromBottomMostTiles) {

                // this information is used for the indexing into the first pattern file...
                initialPatternFileNum = initialPatternFileN;
                initialDotXOffset = initialDotHorizOffset;
                initialDotYOffset = initialDotVertOffset;

                patternPackage = thePatternPackage;

                // every full tile will have this many dots
                numDotsXPerFullTile = patternPackage.getNumPatternColsPerFile();
                numDotsYPerFullTile = patternPackage.getNumPatternRowsPerFile();

                // how many tiles were requested in each direction
                numTilesX = numTilesNeededX;
                numTilesY = numTilesNeededY;

                // number of dots spilled over into the rightmost and bottom most columns...
                numDotsXRightMost = numDotsXFromRightMostTiles;
                numDotsYBottomMost = numDotsYFromBottomMostTiles;

                // error check some values
                boolean advanceToNextPatternPage = false;

                if (initialDotXOffset < 0) {
                        initialDotXOffset = 0;
                } else if (initialDotXOffset > numDotsXPerFullTile) {
                        advanceToNextPatternPage = true;
                }
                if (initialDotYOffset < 0) {
                        initialDotYOffset = 0;
                } else if (initialDotYOffset > numDotsYPerFullTile) {
                        advanceToNextPatternPage = true;
                }

                if (advanceToNextPatternPage) {
                        // move to the next file! because we were out of bounds
                        initialDotXOffset = 0;
                        initialDotYOffset = 0;
                        initialPatternFileNum++;
                }

                // how many columns and rows of pattern we will need, given all the above information
                numTotalColumns = (numTilesX - 1) * numDotsXPerFullTile // all columns before the rightmost
                                + numDotsXFromRightMostTiles; // the rightmost tiles
                numTotalRows = (numTilesY - 1) * numDotsYPerFullTile // all rows before the bottom
                                + numDotsYFromBottomMostTiles; // the bottom row

                // get the origin of the first pattern file
                patternCoordinateOfOrigin = patternPackage
                                .getPatternCoordinateOfOriginOfFile(initialPatternFileNum);

                // adjust the x coordinate for the offset
                patternCoordinateOfOrigin.setX(new PatternDots(patternCoordinateOfOrigin.getXVal()
                                + initialDotXOffset));
                // adjust the y coordinate to account for the offset
                patternCoordinateOfOrigin.setY(new PatternDots(patternCoordinateOfOrigin.getYVal()
                                + initialDotYOffset));

                DebugUtils.println("Origin for this patch of pattern: " + patternCoordinateOfOrigin);

                // read in the pattern information
                loadPattern();
        }

        public int getInitialPatternFileNumber() {
                return initialPatternFileNum;
        }

        public int getLastPatternFileUsed() {
                return lastPatternFileUsed;
        }

        public int getNumDotsXFromRightMostTiles() {
                return numDotsXRightMost;
        }

        public int getNumDotsXPerFullTile() {
                return numDotsXPerFullTile;
        }

        public int getNumDotsYFromBottomMostTiles() {
                return numDotsYBottomMost;
        }

        public int getNumDotsYPerFullTile() {
                return numDotsYPerFullTile;
        }

        public double getNumHorizDotsBetweenTiles() {
                return patternPackage.getNumDotsHorizontalBetweenPages();
        }

        public int getNumTilesX() {
                return numTilesX;
        }

        public int getNumTilesY() {
                return numTilesY;
        }

        public int getNumTotalColumns() {
                return numTotalColumns;
        }

        public int getNumTotalRows() {
                return numTotalRows;
        }

        public double getNumVertDotsBetweenTiles() {
                return patternPackage.getNumDotsVerticalBetweenPages();
        }

        public double getOriginXInDots() {
                return patternCoordinateOfOrigin.getXVal();
        }

        public double getOriginYInDots() {
                return patternCoordinateOfOrigin.getYVal();
        }

        public String getPatternOnRow(int row) {
                return pattern[row].toString();
        }

        private void loadPattern() {
                // System.out.println(this);

                // each string will be numTotalColumns long
                pattern = new StringBuilder[numTotalRows];
                for (int row = 0; row < numTotalRows; row++) {
                        pattern[row] = new StringBuilder();
                }

                // the rectangle of pattern to read from each file goes from
                // 0,0 to numDotsXPerFullTile,numDotsYPerFullTile in dots
                final PatternDots originX = new PatternDots(0);
                final PatternDots originY = new PatternDots(0);
                final PatternDots originXLeftTopMost = new PatternDots(initialDotXOffset);
                final PatternDots originYLeftTopMost = new PatternDots(initialDotYOffset);
                final PatternDots dotsW = new PatternDots(numDotsXPerFullTile);
                final PatternDots dotsH = new PatternDots(numDotsYPerFullTile);
                final PatternDots dotsWRightMost = new PatternDots(numDotsXRightMost);
                final PatternDots dotsHBottomMost = new PatternDots(numDotsYBottomMost);

                // go through each tile and read in the strings...
                // start looking at the correct pattern file number
                // this enables us to get tiled pattern from different parts of our pattern space.
                int patternFileNumber = initialPatternFileNum;

                for (int tileRow = 0; tileRow < numTilesY; tileRow++) {
                        for (int tileCol = 0; tileCol < numTilesX; tileCol++) {

                                // by default, we start from the leftmost and topmost dot
                                PatternDots origX = originX;
                                PatternDots origY = originY;

                                // by default, we want every dot from a pattern file
                                PatternDots width = dotsW;
                                PatternDots height = dotsH;

                                // if leftmost and topmost tile, we want to start from where we were asked to
                                if (tileCol == 0 && tileRow == 0) {
                                        origX = originXLeftTopMost;
                                        origY = originYLeftTopMost;
                                }

                                // if rightmost, we only want the dots that spill over into the rightmost column
                                if (tileCol == numTilesX - 1) {
                                        width = dotsWRightMost;
                                }

                                // if bottommost, we only want the dots that spill into the bottommost row
                                if (tileRow == numTilesY - 1) {
                                        height = dotsHBottomMost;
                                }

                                // if we are on the rightmost or bottommost tile, we need to use alternate bounds
                                DebugUtils.println("PatternFileNumber: " + patternFileNumber);
                                final String[] patternTile = patternPackage.readPatternFromFile(patternFileNumber, //
                                                origX, origY, width, height);

                                // copy the patternTile into our pattern variable
                                // figure out which actual pattern row we start from...
                                int actualPatternRow = tileRow * numDotsYPerFullTile;
                                for (String patternTileRow : patternTile) {
                                        pattern[actualPatternRow].append(patternTileRow);
                                        // next row
                                        actualPatternRow++;
                                }

                                // go to the next file, but keep track of which file we last used.
                                lastPatternFileUsed = patternFileNumber;
                                patternFileNumber++;
                        }
                }
        }

        public String toString() {
                return "Tiling Information {\n" //
                                + "\t" + patternCoordinateOfOrigin + "\n" + "\tDotsX: " + numTotalColumns
                                + " DotsY: "
                                + numTotalRows + "\n" + "\t" + numTilesX
                                + " Tile(s) in X, with "
                                + numDotsXRightMost
                                + " horizontal dots from the rightmost tiles.\n" //
                                + "\t" + numTilesY + " Tile(s) in Y, with "
                                + numDotsYBottomMost
                                + " vertical dots from the bottommost tiles.\n" //
                                + "}";
        }
}

---