| /* |
| * 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$ */ |
| |
| 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; |
| import org.apache.fop.util.bitmap.MonochromeBitmapConverter; |
| |
| /** |
| * 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]; |
| |
| /** |
| * 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"); |
| } |
| |
| /** |
| * 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); |
| } |
| |
| private Dimension getAdjustedDimension(Dimension orgDim, double orgResolution, |
| int pclResolution) { |
| if (orgResolution == pclResolution) { |
| return orgDim; |
| } else { |
| Dimension result = new Dimension(); |
| result.width = (int)Math.round((double)orgDim.width * pclResolution / orgResolution); |
| result.height = (int)Math.round((double)orgDim.height * pclResolution / orgResolution); |
| return result; |
| } |
| } |
| |
| //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(); |
| } |
| |
| BufferedImage src = null; |
| if (img instanceof BufferedImage && !scaled) { |
| if (!isGrayscaleImage(img) || img.getColorModel().hasAlpha()) { |
| /* Disabled as this doesn't work reliably, use the fallback below |
| src = new BufferedImage(effDim.width, effDim.height, |
| BufferedImage.TYPE_BYTE_GRAY); |
| Graphics2D g2d = src.createGraphics(); |
| try { |
| clearBackground(g2d, effDim); |
| } finally { |
| g2d.dispose(); |
| } |
| ColorConvertOp op = new ColorConvertOp( |
| ColorSpace.getInstance(ColorSpace.CS_GRAY), null); |
| op.filter((BufferedImage)img, src); |
| */ |
| } else { |
| src = (BufferedImage)img; |
| } |
| } |
| if (src == null) { |
| src = BitmapImageUtil.convertToGrayscale(img, effDim); |
| } |
| MonochromeBitmapConverter converter |
| = BitmapImageUtil.createDefaultMonochromeBitmapConverter(); |
| converter.setHint("quality", "false"); |
| |
| RenderedImage red = converter.convertToMonochrome(src); |
| 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 void clearBackground(Graphics2D g2d, Dimension effDim) { |
| //white background |
| g2d.setBackground(Color.WHITE); |
| g2d.clearRect(0, 0, effDim.width, effDim.height); |
| } |
| |
| 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; |
| } |
| |
| |
| } |
| |
| } |