Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* $Id: PCLGenerator.java 1067881 2011-02-07 08:39:46Z jeremias $ */ package org.apache.fop.render.pcl; import java.awt.Color; import java.awt.Dimension; import java.awt.Graphics2D; import java.awt.geom.AffineTransform; import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.awt.image.ByteLookupTable; import java.awt.image.ColorModel; import java.awt.image.DataBuffer; import java.awt.image.DataBufferByte; import java.awt.image.IndexColorModel; import java.awt.image.LookupOp; import java.awt.image.MultiPixelPackedSampleModel; import java.awt.image.Raster; import java.awt.image.RenderedImage; import java.awt.image.WritableRaster; import java.io.DataOutputStream; import java.io.IOException; import java.io.OutputStream; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; import java.util.Locale; import org.apache.commons.io.output.ByteArrayOutputStream; import org.apache.xmlgraphics.image.GraphicsUtil; import org.apache.xmlgraphics.util.UnitConv; import org.apache.fop.util.bitmap.BitmapImageUtil; import org.apache.fop.util.bitmap.DitherUtil; /** * This class provides methods for generating PCL print files. */ public class PCLGenerator { private static final String US_ASCII = "US-ASCII"; private static final String ISO_8859_1 = "ISO-8859-1"; /** The ESC (escape) character */ public static final char ESC = '\033'; /** A list of all supported resolutions in PCL (values in dpi) */ public static final int[] PCL_RESOLUTIONS = new int[] { 75, 100, 150, 200, 300, 600 }; private final DecimalFormatSymbols symbols = new DecimalFormatSymbols(Locale.US); private final DecimalFormat df2 = new DecimalFormat("0.##", symbols); private final DecimalFormat df4 = new DecimalFormat("0.####", symbols); private final OutputStream out; private boolean currentSourceTransparency = true; private boolean currentPatternTransparency = true; private int maxBitmapResolution = PCL_RESOLUTIONS[PCL_RESOLUTIONS.length - 1]; private float ditheringQuality = 0.5f; /** * true: Standard PCL shades are used (poor quality). false: user-defined pattern are used * to create custom dither patterns for better grayscale quality. */ private final boolean usePCLShades = false; /** * Main constructor. * @param out the OutputStream to write the PCL stream to */ public PCLGenerator(OutputStream out) { this.out = out; } /** * Main constructor. * @param out the OutputStream to write the PCL stream to * @param maxResolution the maximum resolution to encode bitmap images at */ public PCLGenerator(OutputStream out, int maxResolution) { this(out); boolean found = false; for (int i = 0; i < PCL_RESOLUTIONS.length; i++) { if (PCL_RESOLUTIONS[i] == maxResolution) { found = true; break; } } if (!found) { throw new IllegalArgumentException("Illegal value for maximum resolution!"); } this.maxBitmapResolution = maxResolution; } /** @return the OutputStream that this generator writes to */ public OutputStream getOutputStream() { return this.out; } /** * Returns the currently active text encoding. * @return the text encoding */ public String getTextEncoding() { return ISO_8859_1; } /** @return the maximum resolution to encode bitmap images at */ public int getMaximumBitmapResolution() { return this.maxBitmapResolution; } /** * Writes a PCL escape command to the output stream. * @param cmd the command (without the ESCAPE character) * @throws IOException In case of an I/O error */ public void writeCommand(String cmd) throws IOException { out.write(27); //ESC out.write(cmd.getBytes(US_ASCII)); } /** * Writes raw text (in ISO-8859-1 encoding) to the output stream. * @param s the text * @throws IOException In case of an I/O error */ public void writeText(String s) throws IOException { out.write(s.getBytes(ISO_8859_1)); } /** * Formats a double value with two decimal positions for PCL output. * * @param value value to format * @return the formatted value */ public final String formatDouble2(double value) { return df2.format(value); } /** * Formats a double value with four decimal positions for PCL output. * * @param value value to format * @return the formatted value */ public final String formatDouble4(double value) { return df4.format(value); } /** * Sends the universal end of language command (UEL). * @throws IOException In case of an I/O error */ public void universalEndOfLanguage() throws IOException { writeCommand("%-12345X"); } /** * Resets the printer and restores the user default environment. * @throws IOException In case of an I/O error */ public void resetPrinter() throws IOException { writeCommand("E"); } /** * Sends the job separation command. * @throws IOException In case of an I/O error */ public void separateJobs() throws IOException { writeCommand("&l1T"); } /** * Sends the form feed character. * @throws IOException In case of an I/O error */ public void formFeed() throws IOException { out.write(12); //=OC ("FF", Form feed) } /** * Sets the unit of measure. * @param value the resolution value (units per inch) * @throws IOException In case of an I/O error */ public void setUnitOfMeasure(int value) throws IOException { writeCommand("&u" + value + "D"); } /** * Sets the raster graphics resolution * @param value the resolution value (units per inch) * @throws IOException In case of an I/O error */ public void setRasterGraphicsResolution(int value) throws IOException { writeCommand("*t" + value + "R"); } /** * Selects the page size. * @param selector the integer representing the page size * @throws IOException In case of an I/O error */ public void selectPageSize(int selector) throws IOException { writeCommand("&l" + selector + "A"); } /** * Selects the paper source. The parameter is usually printer-specific. Usually, "1" is the * default tray, "2" is the manual paper feed, "3" is the manual envelope feed, "4" is the * "lower" tray and "7" is "auto-select". Consult the technical reference for your printer * for all available values. * @param selector the integer representing the paper source/tray * @throws IOException In case of an I/O error */ public void selectPaperSource(int selector) throws IOException { writeCommand("&l" + selector + "H"); } /** * Selects the output bin. The parameter is usually printer-specific. Usually, "1" is the * default output bin (upper bin) and "2" is the lower (rear) output bin. Some printers * may support additional output bins. Consult the technical reference for your printer * for all available values. * @param selector the integer representing the output bin * @throws IOException In case of an I/O error */ public void selectOutputBin(int selector) throws IOException { writeCommand("&l" + selector + "G"); } /** * Selects the duplexing mode for the page. * The parameter is usually printer-specific. * "0" means Simplex, * "1" means Duplex, Long-Edge Binding, * "2" means Duplex, Short-Edge Binding. * @param selector the integer representing the duplexing mode of the page * @throws IOException In case of an I/O error */ public void selectDuplexMode(int selector) throws IOException { writeCommand("&l" + selector + "S"); } /** * Clears the horizontal margins. * @throws IOException In case of an I/O error */ public void clearHorizontalMargins() throws IOException { writeCommand("9"); } /** * The Top Margin command designates the number of lines between * the top of the logical page and the top of the text area. * @param numberOfLines the number of lines (See PCL specification for details) * @throws IOException In case of an I/O error */ public void setTopMargin(int numberOfLines) throws IOException { writeCommand("&l" + numberOfLines + "E"); } /** * The Text Length command can be used to define the bottom border. See the PCL specification * for details. * @param numberOfLines the number of lines * @throws IOException In case of an I/O error */ public void setTextLength(int numberOfLines) throws IOException { writeCommand("&l" + numberOfLines + "F"); } /** * Sets the Vertical Motion Index (VMI). * @param value the VMI value * @throws IOException In case of an I/O error */ public void setVMI(double value) throws IOException { writeCommand("&l" + formatDouble4(value) + "C"); } /** * Sets the cursor to a new absolute coordinate. * @param x the X coordinate (in millipoints) * @param y the Y coordinate (in millipoints) * @throws IOException In case of an I/O error */ public void setCursorPos(double x, double y) throws IOException { if (x < 0) { //A negative x value will result in a relative movement so go to "0" first. //But this will most probably have no effect anyway since you can't paint to the left //of the logical page writeCommand("&a0h" + formatDouble2(x / 100) + "h" + formatDouble2(y / 100) + "V"); } else { writeCommand("&a" + formatDouble2(x / 100) + "h" + formatDouble2(y / 100) + "V"); } } /** * Pushes the current cursor position on a stack (stack size: max 20 entries) * @throws IOException In case of an I/O error */ public void pushCursorPos() throws IOException { writeCommand("&f0S"); } /** * Pops the current cursor position from the stack. * @throws IOException In case of an I/O error */ public void popCursorPos() throws IOException { writeCommand("&f1S"); } /** * Changes the current print direction while maintaining the current cursor position. * @param rotate the rotation angle (counterclockwise), one of 0, 90, 180 and 270. * @throws IOException In case of an I/O error */ public void changePrintDirection(int rotate) throws IOException { writeCommand("&a" + rotate + "P"); } /** * Enters the HP GL/2 mode. * @param restorePreviousHPGL2Cursor true if the previous HP GL/2 pen position should be * restored, false if the current position is maintained * @throws IOException In case of an I/O error */ public void enterHPGL2Mode(boolean restorePreviousHPGL2Cursor) throws IOException { if (restorePreviousHPGL2Cursor) { writeCommand("%0B"); } else { writeCommand("%1B"); } } /** * Enters the PCL mode. * @param restorePreviousPCLCursor true if the previous PCL cursor position should be restored, * false if the current position is maintained * @throws IOException In case of an I/O error */ public void enterPCLMode(boolean restorePreviousPCLCursor) throws IOException { if (restorePreviousPCLCursor) { writeCommand("%0A"); } else { writeCommand("%1A"); } } /** * Generate a filled rectangle at the current cursor position. * * @param w the width in millipoints * @param h the height in millipoints * @param col the fill color * @throws IOException In case of an I/O error */ protected void fillRect(int w, int h, Color col) throws IOException { if ((w == 0) || (h == 0)) { return; } if (h < 0) { h *= -1; } else { //y += h; } setPatternTransparencyMode(false); if (usePCLShades || Color.black.equals(col) || Color.white.equals(col)) { writeCommand("*c" + formatDouble4(w / 100.0) + "h" + formatDouble4(h / 100.0) + "V"); int lineshade = convertToPCLShade(col); writeCommand("*c" + lineshade + "G"); writeCommand("*c2P"); //Shaded fill } else { defineGrayscalePattern(col, 32, DitherUtil.DITHER_MATRIX_4X4); writeCommand("*c" + formatDouble4(w / 100.0) + "h" + formatDouble4(h / 100.0) + "V"); writeCommand("*c32G"); writeCommand("*c4P"); //User-defined pattern } // Reset pattern transparency mode. setPatternTransparencyMode(true); } /** * Generates a user-defined pattern for a dithering pattern matching the grayscale value * of the color given. * @param col the color to create the pattern for * @param patternID the pattern ID to use * @param ditherMatrixSize the size of the Bayer dither matrix to use (4 or 8 supported) * @throws IOException In case of an I/O error */ public void defineGrayscalePattern(Color col, int patternID, int ditherMatrixSize) throws IOException { ByteArrayOutputStream baout = new ByteArrayOutputStream(); DataOutputStream data = new DataOutputStream(baout); data.writeByte(0); //Format data.writeByte(0); //Continuation data.writeByte(1); //Pixel Encoding data.writeByte(0); //Reserved data.writeShort(8); //Width in Pixels data.writeShort(8); //Height in Pixels //data.writeShort(600); //X Resolution (didn't manage to get that to work) //data.writeShort(600); //Y Resolution int gray255 = convertToGray(col.getRed(), col.getGreen(), col.getBlue()); byte[] pattern; if (ditherMatrixSize == 8) { pattern = DitherUtil.getBayerDither(DitherUtil.DITHER_MATRIX_8X8, gray255, false); } else { //Since a 4x4 pattern did not work, the 4x4 pattern is applied 4 times to an //8x8 pattern. Maybe this could be changed to use an 8x8 bayer dither pattern //instead of the 4x4 one. pattern = DitherUtil.getBayerDither(DitherUtil.DITHER_MATRIX_4X4, gray255, true); } data.write(pattern); if ((baout.size() % 2) > 0) { baout.write(0); } writeCommand("*c" + patternID + "G"); writeCommand("*c" + baout.size() + "W"); baout.writeTo(this.out); writeCommand("*c4Q"); //temporary pattern } /** * Sets the source transparency mode. * @param transparent true if transparent, false for opaque * @throws IOException In case of an I/O error */ public void setSourceTransparencyMode(boolean transparent) throws IOException { setTransparencyMode(transparent, currentPatternTransparency); } /** * Sets the pattern transparency mode. * @param transparent true if transparent, false for opaque * @throws IOException In case of an I/O error */ public void setPatternTransparencyMode(boolean transparent) throws IOException { setTransparencyMode(currentSourceTransparency, transparent); } /** * Sets the transparency modes. * @param source source transparency: true if transparent, false for opaque * @param pattern pattern transparency: true if transparent, false for opaque * @throws IOException In case of an I/O error */ public void setTransparencyMode(boolean source, boolean pattern) throws IOException { if (source != currentSourceTransparency && pattern != currentPatternTransparency) { writeCommand("*v" + (source ? '0' : '1') + "n" + (pattern ? '0' : '1') + "O"); } else if (source != currentSourceTransparency) { writeCommand("*v" + (source ? '0' : '1') + "N"); } else if (pattern != currentPatternTransparency) { writeCommand("*v" + (pattern ? '0' : '1') + "O"); } this.currentSourceTransparency = source; this.currentPatternTransparency = pattern; } /** * Convert an RGB color value to a grayscale from 0 to 100. * @param r the red component * @param g the green component * @param b the blue component * @return the gray value */ public final int convertToGray(int r, int g, int b) { return BitmapImageUtil.convertToGray(r, g, b); } /** * Convert a Color value to a PCL shade value (0-100). * @param col the color * @return the PCL shade value (100=black) */ public final int convertToPCLShade(Color col) { float gray = convertToGray(col.getRed(), col.getGreen(), col.getBlue()) / 255f; return (int) (100 - (gray * 100f)); } /** * Selects the current grayscale color (the given color is converted to grayscales). * @param col the color * @throws IOException In case of an I/O error */ public void selectGrayscale(Color col) throws IOException { if (Color.black.equals(col)) { selectCurrentPattern(0, 0); //black } else if (Color.white.equals(col)) { selectCurrentPattern(0, 1); //white } else { if (usePCLShades) { selectCurrentPattern(convertToPCLShade(col), 2); } else { defineGrayscalePattern(col, 32, DitherUtil.DITHER_MATRIX_4X4); selectCurrentPattern(32, 4); } } } /** * Select the current pattern * @param patternID the pattern ID (<ESC>*c#G command) * @param pattern the pattern type (<ESC>*v#T command) * @throws IOException In case of an I/O error */ public void selectCurrentPattern(int patternID, int pattern) throws IOException { if (pattern > 1) { writeCommand("*c" + patternID + "G"); } writeCommand("*v" + pattern + "T"); } /** * Sets the dithering quality used when encoding gray or color images. If not explicitely * set a medium setting (0.5f) is used. * @param quality a quality setting between 0.0f (worst/fastest) and 1.0f (best/slowest) */ public void setDitheringQuality(float quality) { quality = Math.min(Math.max(0f, quality), 1.0f); this.ditheringQuality = quality; } /** * Returns the dithering quality used when encoding gray or color images. * @return the quality setting between 0.0f (worst/fastest) and 1.0f (best/slowest) */ public float getDitheringQuality() { return this.ditheringQuality; } /** * Indicates whether an image is a monochrome (b/w) image. * @param img the image * @return true if it's a monochrome image */ public static boolean isMonochromeImage(RenderedImage img) { return BitmapImageUtil.isMonochromeImage(img); } /** * Indicates whether an image is a grayscale image. * @param img the image * @return true if it's a grayscale image */ public static boolean isGrayscaleImage(RenderedImage img) { return BitmapImageUtil.isGrayscaleImage(img); } private static int jaiAvailable = -1; //no synchronization necessary, not critical /** * Indicates whether JAI is available. JAI has shown to be reliable when dithering a * grayscale or color image to monochrome bitmaps (1-bit). * @return true if JAI is available */ public static boolean isJAIAvailable() { if (jaiAvailable < 0) { try { String clName = "javax.media.jai.JAI"; Class.forName(clName); jaiAvailable = 1; } catch (ClassNotFoundException cnfe) { jaiAvailable = 0; } } return (jaiAvailable > 0); } private int calculatePCLResolution(int resolution) { return calculatePCLResolution(resolution, false); } /** * Calculates the ideal PCL resolution for a given resolution. * @param resolution the input resolution * @param increased true if you want to go to a higher resolution, for example if you * convert grayscale or color images to monochrome images so dithering has * a chance to generate better quality. * @return the resulting PCL resolution (one of 75, 100, 150, 200, 300, 600) */ private int calculatePCLResolution(int resolution, boolean increased) { int choice = -1; for (int i = PCL_RESOLUTIONS.length - 2; i >= 0; i--) { if (resolution > PCL_RESOLUTIONS[i]) { int idx = i + 1; if (idx < PCL_RESOLUTIONS.length - 2) { idx += increased ? 2 : 0; } else if (idx < PCL_RESOLUTIONS.length - 1) { idx += increased ? 1 : 0; } choice = idx; break; //return PCL_RESOLUTIONS[idx]; } } if (choice < 0) { choice = (increased ? 2 : 0); } while (choice > 0 && PCL_RESOLUTIONS[choice] > getMaximumBitmapResolution()) { choice--; } return PCL_RESOLUTIONS[choice]; } private boolean isValidPCLResolution(int resolution) { return resolution == calculatePCLResolution(resolution); } //Threshold table to convert an alpha channel (8-bit) into a clip mask (1-bit) private static final byte[] THRESHOLD_TABLE = new byte[256]; static { // Initialize the arrays for (int i = 0; i < 256; i++) { THRESHOLD_TABLE[i] = (byte) ((i < 240) ? 255 : 0); } } private RenderedImage getMask(RenderedImage img, Dimension targetDim) { ColorModel cm = img.getColorModel(); if (cm.hasAlpha()) { BufferedImage alpha = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_BYTE_GRAY); Raster raster = img.getData(); GraphicsUtil.copyBand(raster, cm.getNumColorComponents(), alpha.getRaster(), 0); BufferedImageOp op1 = new LookupOp(new ByteLookupTable(0, THRESHOLD_TABLE), null); BufferedImage alphat = op1.filter(alpha, null); BufferedImage mask; if (true) { mask = new BufferedImage(targetDim.width, targetDim.height, BufferedImage.TYPE_BYTE_BINARY); } else { byte[] arr = { (byte) 0, (byte) 0xff }; ColorModel colorModel = new IndexColorModel(1, 2, arr, arr, arr); WritableRaster wraster = Raster.createPackedRaster(DataBuffer.TYPE_BYTE, targetDim.width, targetDim.height, 1, 1, null); mask = new BufferedImage(colorModel, wraster, false, null); } Graphics2D g2d = mask.createGraphics(); try { AffineTransform at = new AffineTransform(); double sx = targetDim.getWidth() / img.getWidth(); double sy = targetDim.getHeight() / img.getHeight(); at.scale(sx, sy); g2d.drawRenderedImage(alphat, at); } finally { g2d.dispose(); } /* try { BatchDiffer.saveAsPNG(alpha, new java.io.File("D:/out-alpha.png")); BatchDiffer.saveAsPNG(mask, new java.io.File("D:/out-mask.png")); } catch (IOException e) { e.printStackTrace(); }*/ return mask; } else { return null; } } /** * Paint a bitmap at the current cursor position. The bitmap is converted to a monochrome * (1-bit) bitmap image. * @param img the bitmap image * @param targetDim the target Dimention (in mpt) * @param sourceTransparency true if the background should not be erased * @throws IOException In case of an I/O error */ public void paintBitmap(RenderedImage img, Dimension targetDim, boolean sourceTransparency) throws IOException { double targetHResolution = img.getWidth() / UnitConv.mpt2in(targetDim.width); double targetVResolution = img.getHeight() / UnitConv.mpt2in(targetDim.height); double targetResolution = Math.max(targetHResolution, targetVResolution); int resolution = (int) Math.round(targetResolution); int effResolution = calculatePCLResolution(resolution, true); Dimension orgDim = new Dimension(img.getWidth(), img.getHeight()); Dimension effDim; if (targetResolution == effResolution) { effDim = orgDim; //avoid scaling side-effects } else { effDim = new Dimension((int) Math.ceil(UnitConv.mpt2px(targetDim.width, effResolution)), (int) Math.ceil(UnitConv.mpt2px(targetDim.height, effResolution))); } boolean scaled = !orgDim.equals(effDim); //ImageWriterUtil.saveAsPNG(img, new java.io.File("D:/text-0-org.png")); boolean monochrome = isMonochromeImage(img); if (!monochrome) { //Transparency mask disabled. Doesn't work reliably final boolean transparencyDisabled = true; RenderedImage mask = (transparencyDisabled ? null : getMask(img, effDim)); if (mask != null) { pushCursorPos(); selectCurrentPattern(0, 1); //Solid white setTransparencyMode(true, true); paintMonochromeBitmap(mask, effResolution); popCursorPos(); } RenderedImage red = BitmapImageUtil.convertToMonochrome(img, effDim, this.ditheringQuality); selectCurrentPattern(0, 0); //Solid black setTransparencyMode(sourceTransparency || mask != null, true); paintMonochromeBitmap(red, effResolution); } else { RenderedImage effImg = img; if (scaled) { effImg = BitmapImageUtil.convertToMonochrome(img, effDim); } setSourceTransparencyMode(sourceTransparency); selectCurrentPattern(0, 0); //Solid black paintMonochromeBitmap(effImg, effResolution); } } private int toGray(int rgb) { // see http://www.jguru.com/faq/view.jsp?EID=221919 double greyVal = 0.072169d * (rgb & 0xff); rgb >>= 8; greyVal += 0.715160d * (rgb & 0xff); rgb >>= 8; greyVal += 0.212671d * (rgb & 0xff); return (int) greyVal; } /** * Paint a bitmap at the current cursor position. The bitmap must be a monochrome * (1-bit) bitmap image. * @param img the bitmap image (must be 1-bit b/w) * @param resolution the resolution of the image (must be a PCL resolution) * @throws IOException In case of an I/O error */ public void paintMonochromeBitmap(RenderedImage img, int resolution) throws IOException { if (!isValidPCLResolution(resolution)) { throw new IllegalArgumentException("Invalid PCL resolution: " + resolution); } boolean monochrome = isMonochromeImage(img); if (!monochrome) { throw new IllegalArgumentException("img must be a monochrome image"); } setRasterGraphicsResolution(resolution); writeCommand("*r0f" + img.getHeight() + "t" + img.getWidth() + "s1A"); Raster raster = img.getData(); Encoder encoder = new Encoder(img); // Transfer graphics data int imgw = img.getWidth(); IndexColorModel cm = (IndexColorModel) img.getColorModel(); if (cm.getTransferType() == DataBuffer.TYPE_BYTE) { DataBufferByte dataBuffer = (DataBufferByte) raster.getDataBuffer(); MultiPixelPackedSampleModel packedSampleModel = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, img.getWidth(), img.getHeight(), 1); if (img.getSampleModel().equals(packedSampleModel) && dataBuffer.getNumBanks() == 1) { //Optimized packed encoding byte[] buf = dataBuffer.getData(); int scanlineStride = packedSampleModel.getScanlineStride(); int idx = 0; int c0 = toGray(cm.getRGB(0)); int c1 = toGray(cm.getRGB(1)); boolean zeroIsWhite = c0 > c1; for (int y = 0, maxy = img.getHeight(); y < maxy; y++) { for (int x = 0, maxx = scanlineStride; x < maxx; x++) { if (zeroIsWhite) { encoder.add8Bits(buf[idx]); } else { encoder.add8Bits((byte) ~buf[idx]); } idx++; } encoder.endLine(); } } else { //Optimized non-packed encoding for (int y = 0, maxy = img.getHeight(); y < maxy; y++) { byte[] line = (byte[]) raster.getDataElements(0, y, imgw, 1, null); for (int x = 0, maxx = imgw; x < maxx; x++) { encoder.addBit(line[x] == 0); } encoder.endLine(); } } } else { //Safe but slow fallback for (int y = 0, maxy = img.getHeight(); y < maxy; y++) { for (int x = 0, maxx = imgw; x < maxx; x++) { int sample = raster.getSample(x, y, 0); encoder.addBit(sample == 0); } encoder.endLine(); } } // End raster graphics writeCommand("*rB"); } private class Encoder { private int imgw; private int bytewidth; private byte[] rle; //compressed (RLE) private byte[] uncompressed; //uncompressed private int lastcount = -1; private byte lastbyte = 0; private int rlewidth = 0; private byte ib = 0; //current image bits private int x = 0; private boolean zeroRow = true; public Encoder(RenderedImage img) { imgw = img.getWidth(); bytewidth = (imgw / 8); if ((imgw % 8) != 0) { bytewidth++; } rle = new byte[bytewidth * 2]; uncompressed = new byte[bytewidth]; } public void addBit(boolean bit) { //Set image bit for black if (bit) { ib |= 1; } //RLE encoding if ((x % 8) == 7 || ((x + 1) == imgw)) { finishedByte(); } else { ib <<= 1; } x++; } public void add8Bits(byte b) { ib = b; finishedByte(); x += 8; } private void finishedByte() { if (rlewidth < bytewidth) { if (lastcount >= 0) { if (ib == lastbyte) { lastcount++; } else { rle[rlewidth++] = (byte) (lastcount & 0xFF); rle[rlewidth++] = lastbyte; lastbyte = ib; lastcount = 0; } } else { lastbyte = ib; lastcount = 0; } if (lastcount == 255 || ((x + 1) == imgw)) { rle[rlewidth++] = (byte) (lastcount & 0xFF); rle[rlewidth++] = lastbyte; lastbyte = 0; lastcount = -1; } } uncompressed[x / 8] = ib; if (ib != 0) { zeroRow = false; } ib = 0; } public void endLine() throws IOException { if (zeroRow && PCLGenerator.this.currentSourceTransparency) { writeCommand("*b1Y"); } else if (rlewidth < bytewidth) { writeCommand("*b1m" + rlewidth + "W"); out.write(rle, 0, rlewidth); } else { writeCommand("*b0m" + bytewidth + "W"); out.write(uncompressed); } lastcount = -1; rlewidth = 0; ib = 0; x = 0; zeroRow = true; } } }