Android: Converting a Bitmap to a Monochrome Bitmap (1 Bit per Pixel)

Question

I want to print a Bitmap to a mobile Bluetooth Printer (Bixolon SPP-R200) - the SDK doesn't offer direkt methods to print an in-memory image. So I thought about converting a Bitmap like this:

Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); 

To a Monochrome Bitmap. I am drawing black text on above given Bitmap using a Canvas, which works well. However, when I convert the above Bitmap to a ByteArray, the printer seems to be unable to handle those bytes. I suspect I need an Array with one Bit per Pixel (a Pixel would be either white = 1 or black = 0).

As there seems to be no convenient, out of the box way to do that, one idea I had was to use:

bitmap.getPixels(pixels, offset, stride, x, y, width, height) 

to Obtain the pixels. I assume, I'd have to use it as follows:

int width = bitmap.getWidth(); int height = bitmap.getHeight();  int [] pixels = new int [width * height]; bitmap.getPixels(pixels, 0, width, 0, 0, width, height); 

However - I am not sure about a few things:

• In getPixels - does it make sense to simply pass the width as the "Stride" argument?
• I guess I'd have to evaluate the color information of each pixel and either switch it to black or white (And I'd write this value in a new target byte array which I would ultimately pass to the printer)?
• How to best evaluate each pixel color information in order to decide that it should be black or white? (The rendered Bitmap is black pain on a white background)

Does this approach make sense at all? Is there an easier way? It's not enough to just make the bitmap black & white, the main issue is to reduce the color information for each pixel into one bit.

UPDATE

As suggested by Reuben I'll first convert the Bitmap to a monochrome Bitmap. and then I'll iterate over each pixel:

    int width = bitmap.getWidth();     int height = bitmap.getHeight();      int[] pixels = new int[width * height];     bitmap.getPixels(pixels, 0, width, 0, 0, width, height);      // Iterate over height     for (int y = 0; y < height; y++) {         int offset = y * height;         // Iterate over width         for (int x = 0; x < width; x++) {             int pixel = bitmap.getPixel(x, y);         }     } 

Now Reuben suggested to "read the lowest byte of each 32-bit pixel" - that would relate to my question about how to evaluate the pixel color. My last question in this regard: Do I get the lowest byte by simply doing this:

// Using the pixel from bitmap.getPixel(x,y) int lowestByte = pixel & 0xff; 

Answer 1

You can convert the image to monochrome 32bpp using a ColorMatrix.

Bitmap bmpMonochrome = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(bmpMonochrome); ColorMatrix ma = new ColorMatrix(); ma.setSaturation(0); Paint paint = new Paint(); paint.setColorFilter(new ColorMatrixColorFilter(ma)); canvas.drawBitmap(bmpSrc, 0, 0, paint); 

That simplifies the color->monochrome conversion. Now you can just do a getPixels() and read the lowest byte of each 32-bit pixel. If it's <128 it's a 0, otherwise it's a 1.

Answer 2

Well I think its quite late now to reply to this thread but I was also working on this stuff sometimes back and decided to build my own library that will convert any jpg or png image to 1bpp .bmp. Most printers that require 1bpp images will support this image (tested on one of those :)). Here you can find library as well as a test project that uses it to make a monochrome single channel image. Feel free to change it..:)

https://github.com/acdevs/1bpp-monochrome-android

Enjoy..!! :)

Answer 3

Converting to monochrome with exact the same size as the original bitmap is not enough to print.

Printers can only print each "pixel" (dot) as monochrome because each spot of ink has only 1 color, so they must use much more dots than enough and adjust their size, density... to emulate the grayscale-like feel. This technique is called halftoning. You can see that printers often have resolution at least 600dpi, normally 1200-4800dpi, while display screen often tops at 200-300ppi.

So your monochrome bitmap should be at least 3 times the original resolution in each side.

Answer 4

You should convert each pixel into HSV space and use the value to determine if the Pixel on the target image should be black or white:

  Bitmap bwBitmap = Bitmap.createBitmap( bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.RGB_565 );   float[] hsv = new float[ 3 ];   for( int col = 0; col < bitmap.getWidth(); col++ ) {     for( int row = 0; row < bitmap.getHeight(); row++ ) {       Color.colorToHSV( bitmap.getPixel( col, row ), hsv );       if( hsv[ 2 ] > 0.5f ) {         bwBitmap.setPixel( col, row, 0xffffffff );       } else {         bwBitmap.setPixel( col, row, 0xff000000 );       }     }   }   return bwBitmap;