PDFPatternGenerator.java

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

import java.awt.Color;
import java.awt.geom.AffineTransform;
import java.io.IOException;

import com.lowagie.text.DocumentException;
import com.lowagie.text.pdf.BaseFont;
import com.lowagie.text.pdf.PdfContentByte;
import com.lowagie.text.pdf.PdfTemplate;

import edu.stanford.hci.r3.pattern.PatternJitter;
import edu.stanford.hci.r3.pattern.TiledPattern;
import edu.stanford.hci.r3.units.Units;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.MathUtils;

public class PDFPatternGenerator {

        private static final BaseFont BFONT_TAHOMA = createBaseFontTahoma();

        private static final BaseFont BFONT_ZAPF = createBaseFontZapfDingbats();

        private static final double convertHundredthsOfMMToPoints = 72 / 2540.0;

        private static final double convertPointsToHundredthsOfMM = 2540.0 / 72;

        private static final boolean DEBUG_PATTERN = false;

        private static final int DEFAULT_JITTER = 5;

        private static final int DEFAULT_PADDING = 30;

        private static final int X_FONT_OFFSET = -2;

        private static final int Y_FONT_OFFSET = 9;

        private static BaseFont createBaseFontTahoma() {
                try {
                        return BaseFont.createFont("/fonts/tahoma.ttf", BaseFont.CP1252, BaseFont.EMBEDDED);
                } catch (DocumentException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return null;
        }

        private static BaseFont createBaseFontZapfDingbats() {
                try {
                        return BaseFont.createFont(BaseFont.ZAPFDINGBATS, BaseFont.CP1252, BaseFont.NOT_EMBEDDED);
                } catch (DocumentException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return null;
        }

        private PdfContentByte content;

        private BaseFont debugFont;

        private String dotSymbol;

        private PdfTemplate dotTemplate;

        private int fontSize;

        private Units height;

        private Color patternColor = Color.BLACK;

        private BaseFont patternFont;

        private boolean useTemplateInsteadOfFont = true;

        private Units width;

        public PDFPatternGenerator(PdfContentByte cb, Units w, Units h) {
                content = cb;
                width = w;
                height = h;

                // transforms the content layer ONCE
                // instead of specifying stuff in points (72 in an inch), we can now
                // specify in 1/100 of a millimeter
                // we need to scale down the numbers so when we specify something at 2540,
                // we get only 72 points...
                content.transform(AffineTransform.getScaleInstance(convertHundredthsOfMMToPoints,
                                convertHundredthsOfMMToPoints));

                if (useTemplateInsteadOfFont) {
                        createDotTemplate(0 /* default */);
                }

                // even if we are using templates, initialize fonts... for debugging
                // initializePatternFont_Tahoma();
                initializePatternFont_Zapf(); // *slightly* smaller file due to built-in font
        }

        public void adjustPatternSize(int patternDotSizeAdjustment) {
                if (useTemplateInsteadOfFont) {
                        // if template aproach
                        createDotTemplate(patternDotSizeAdjustment);
                } else {
                        // if font approach
                        fontSize += patternDotSizeAdjustment;
                }
        }

        private void createDotTemplate(float adjustment) {
                float radiusAdjustment = 0.5f * adjustment;
                final float defaultRadius = 2.8f; // this is key (the right size)
                float xCenter = defaultRadius;
                float yCenter = defaultRadius;

                // the dot as a pdf template (a rubber stamp)
                dotTemplate = content.createTemplate(2 * xCenter + 1, 2 * yCenter + 1);
                dotTemplate.circle(xCenter, yCenter, defaultRadius + radiusAdjustment);
                dotTemplate.fill();
        }

        @SuppressWarnings("unused")
        private void initializePatternFont_Tahoma() {
                setPatternFontSize(21);
                debugFont = BFONT_TAHOMA;
                patternFont = BFONT_TAHOMA;
                dotSymbol = "•";
        }

        private void initializePatternFont_Zapf() {
                setPatternFontSize(7);
                debugFont = BFONT_TAHOMA;
                patternFont = BFONT_ZAPF;
                dotSymbol = "l";
        }

        public void renderPattern(TiledPattern pattern, Units xOrigin, Units yOrigin) {
                // flip the transform so that the top left of the page is 0,0

                float heightOfPDF = (float) height.getValueInPoints();

                // convert the origins to Points
                final double xOrigInPoints = xOrigin.getValueInPoints();
                final double yOrigInPoints = yOrigin.getValueInPoints();

                final int numRows = pattern.getNumTotalRows();
                final int numCols = pattern.getNumTotalColumns();

                // this actually mirrors everything
                // text will display upside down!
                // this doesn't matter for symmetrical dots, though
                // content.concatCTM(1f, 0f, 0f, -1f, 0f, heightOfPDF);

                // work in hundredths of a millimeter
                final float heightInHundredths = (float) (heightOfPDF * convertPointsToHundredthsOfMM);

                // if we use the font approach
                if (!useTemplateInsteadOfFont) {
                        content.beginText();
                        // GRAY, etc. do not work! The printer will do halftoning, which messes things up.
                        content.setFontAndSize(patternFont, fontSize);
                }

                content.setColorFill(patternColor);
                // content.setColorFill(Color.CYAN);
                // content.setColorFill(Color.BLACK);

                final int initX = MathUtils.rint(xOrigInPoints * convertPointsToHundredthsOfMM);

                int gridXPosition = initX;
                int gridYPosition = MathUtils.rint(yOrigInPoints * convertPointsToHundredthsOfMM);

                DebugUtils.println("PDFPatternGenerator: Dot Position is " + gridXPosition + " " + gridYPosition);

                int xJitter = 0;
                int yJitter = 0;
                char currentJitterDirection;

                for (int row = 0; row < numRows; row++) {

                        final String patternRow = pattern.getPatternOnRow(row);
                        final int rowLength = patternRow.length();

                        for (int i = 0; i < rowLength; i++) {

                                // read the direction
                                currentJitterDirection = patternRow.charAt(i);

                                // reset the jitters (this is key!)
                                xJitter = 0;
                                yJitter = 0;

                                switch (currentJitterDirection) {
                                case PatternJitter.DOWN:
                                        // System.out.print("d");
                                        yJitter = DEFAULT_JITTER;
                                        break;
                                case PatternJitter.UP:
                                        // System.out.print("u");
                                        yJitter = -DEFAULT_JITTER;
                                        break;
                                case PatternJitter.LEFT:
                                        // System.out.print("l");
                                        xJitter = -DEFAULT_JITTER;
                                        break;
                                case PatternJitter.RIGHT:
                                        // System.out.print("r");
                                        xJitter = DEFAULT_JITTER;
                                        break;
                                }

                                if (useTemplateInsteadOfFont) {
                                        content.addTemplate(dotTemplate, gridXPosition + xJitter, //
                                                        heightInHundredths - (gridYPosition + yJitter));
                                } else {
                                        content.showTextAligned(PdfContentByte.ALIGN_CENTER, dotSymbol, //
                                                        gridXPosition + xJitter + X_FONT_OFFSET, //
                                                        heightInHundredths - (gridYPosition + yJitter + Y_FONT_OFFSET), 0);
                                }

                                gridXPosition += DEFAULT_PADDING;

                        }
                        gridXPosition = initX;
                        gridYPosition += DEFAULT_PADDING;
                        // System.out.println();
                }

                if (!useTemplateInsteadOfFont) {
                        content.endText();
                }
        }

        public void setPatternColor(Color c) {
                patternColor = c;
        }

        private void setPatternFontSize(int s) {
                fontSize = s;
        }
}

---