Bitmap issues

[davidcx]

Having fun with the printer, but a couple of questions regarding bitmaps:

1) Has anyone succeeded in downloading bitmaps into memory using GS *? I just get a spew of random characters on the printer. It's possible my code is borked, but since my DC2 * code works fine, I suspect it's more likely a documentation problem.

2) Are others experiencing white horizontal lines? They are highly visible in images, but also sometimes noticeable in text. I've tried experimenting with both ESC 7 (printing dots, heating time, heating interval) and DC2 # (printing density and break time), but I can't find a solution that removes the lines without overexposing the image:

Thermal printer white lines.

377989_2888034473660_1044126991_32970184_1369101081_n.jpg (82.13 KiB) Viewed 520 times

-davidc

[commy]

Hi davidc

Nice project! Could you please share the code of how you print those nice grayscale photos?

Thanks.

[davidcx]

Sure, it's a bannedïve implementation of Floyd-Steinberg dithering, with a first pass to get the average brightness to calculate the threshold for black and white. As a prototype, it's highly inefficient and I haven't optimised to take account that the colours are only black and white. Let me know if you get horizontal stripes too!

Code: Select all

package net.davidc.thermal;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

import gnu.io.CommPortIdentifier;

/**
* @author David Croft (davidc.net)
* @version $Id: FloydSteinbergDither.java 45 2012-01-16 20:14:04Z david $
*/
public class FloydSteinbergDither
{
  private FloydSteinbergDither()
  {
  }

  public static float getAverageBrightness(BufferedImage srcImage)
  {
    long accum = 0;

    int width = srcImage.getWidth();
    int height = srcImage.getHeight();

    for (int y = 0; y < height; ++y) {
      for (int x = 0; x < width; ++x) {
        int srcColour = srcImage.getRGB(x, y);
        accum += (srcColour & 0xff) + (srcColour >> 8 & 0xff) + (srcColour >> 16 & 0xff);
      }
    }

    return (float) (accum / (width * height * 3.0 * 255));
  }

  // NB: Will corrupt source image!
  public static BufferedImage dither(BufferedImage srcImage, float threshold)
  {
    int width = srcImage.getWidth();
    int height = srcImage.getHeight();

    BufferedImage destImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);

    for (int y = 0; y < height; ++y) {
      for (int x = 0; x < width; ++x) {

        int srcColour = srcImage.getRGB(x, y);

        float brightness = ((srcColour & 0xff) + (srcColour >> 8 & 0xff) + (srcColour >> 16 & 0xff)) / (3.0f * 255);
        int destColour = brightness >= threshold ? 0xffffffff : 0xff000000;

        destImage.setRGB(x, y, destColour);

        // TODO simplify, since we know it's either 0xff or 0x00, in all channels
        int redError = (srcColour & 0xff) - (destColour & 0xff);
        int greenError = (srcColour >> 8 & 0xff) - (destColour >> 8 & 0xff);
        int blueError = (srcColour >> 16 & 0xff) - (destColour >> 16 & 0xff);

        if (x + 1 < width) {
          diffuseError(srcImage, x + 1, y + 0, (redError * 7) >> 4, (greenError * 7) >> 4, (blueError * 7) >> 4);
        }
        if (y + 1 < height) {
          if (x - 1 >= 0) {
            diffuseError(srcImage, x - 1, y + 1, (redError * 3) >> 4, (greenError * 3) >> 4, (blueError * 3) >> 4);
          }
          diffuseError(srcImage, x + 0, y + 1, (redError * 5) >> 4, (greenError * 5) >> 4, (blueError * 5) >> 4);
          if (x + 1 < width) {
            diffuseError(srcImage, x + 1, y + 1, (redError * 1) >> 4, (greenError * 1) >> 4, (blueError * 1) >> 4);
          }
        }
      }
    }

    return destImage;
  }

  private static void diffuseError(BufferedImage srcImage, int x, int y, int redError, int greenError, int blueError)
  {
    // already checked by caller
//        if (x < 0 || x >= srcImage.getWidth() || y >= srcImage.getHeight()) { // y can never be < 0
//      return;
//    }

    int colour = srcImage.getRGB(x, y);

    int red = (colour & 0xff) + redError;
    int green = (colour >> 8 & 0xff) + greenError;
    int blue = (colour >> 16 & 0xff) + blueError;

    if (red < 0) red = 0;
    else if (red > 255) red = 255;
    if (green < 0) green = 0;
    else if (green > 255) green = 255;
    if (blue < 0) blue = 0;
    else if (blue > 255) blue = 255;

    colour = 0xff000000 | red | (green << 8) | (blue << 16);

    srcImage.setRGB(x, y, colour);
  }

  public static void main(String[] args) throws Exception
  {
    BufferedImage src = ImageIO.read(new File("lenna.png"));
//    src = src.getSubimage(64, 0, 384, 512);

    float averageBrightness = getAverageBrightness(src);
    System.out.println("averageBrightness = " + averageBrightness);

    BufferedImage dest = dither(src, averageBrightness);

    ImageIO.write(dest, "PNG", new File("lenna-out.png"));
//    printImage(dest);
  }

  private static void printImage(BufferedImage dest) throws Exception
  {
    ThermalPrinter printer = new ThermalPrinter(CommPortIdentifier.getPortIdentifier("COM6"));
    try {
      printer.reset();
      printer.setPrintingDensity(2, 0);
      printer.printArbitraryHeightBitmap(dest);
    }
    finally {
      printer.close();
    }
  }
}