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

I think that keep the color will produce better 1 bit pixel image; I have commented the high contract filter and gray matrix, if want to try.

I don't have benchmark the code for speed, the objective is sending data to POS printer, 96 pixel (screen) can be converted to 203 pixel (printer)

if you prefix the image with BMP header (62 bytes), maybe can be converted to BMP format.

I'm using C# with SkiaSharp, but can be useful for java code.

    static int WidthBytes(int bits)
    {
        return ((((bits) + 31) / 32) * 4);
    }
    
    internal static byte[] GetByteArray(SKBitmap bmp, bool reverseBlack, out SKSize size, float dpi = 203f)
    {
        var bytesPerPixel = bmp.BytesPerPixel;
        var ratio = dpi / 96f;
        //var ratio = 1.0f;
        var nHeight = (int)Math.Round(bmp.Height * ratio);
        var prnWidth = (int)Math.Round(bmp.Width * ratio);
        var remain = prnWidth % 8;
        if (remain > 0) prnWidth += (8 - remain);
        var bitWidth = WidthBytes(prnWidth);
        var nWidth = bitWidth - (prnWidth % bitWidth);
        nWidth += prnWidth;
        //var grayScale = new float[]
        //        {
        //            0.21f, 0.72f, 0.07f, 0, 0,
        //            0.21f, 0.72f, 0.07f, 0, 0,
        //            0.21f, 0.72f, 0.07f, 0, 0,
        //            0,     0,     0,     1, 0
        //        };
        //var colorFilter = SKColorFilter.CreateColorMatrix(grayScale);
        //SKHighContrastConfig config = new SKHighContrastConfig(true, SKHighContrastConfigInvertStyle.NoInvert, 0.2f);
        //var colorFilter = SKColorFilter.CreateHighContrast(config);
        var bmp1 = new SKBitmap(nWidth, nHeight, SKColorType.Bgra8888, SKAlphaType.Opaque);
        var canvas = new SKCanvas(bmp1);
        using (SKPaint paint = new SKPaint())
        {
            var backColor = reverseBlack ? SKColors.Black : SKColors.White;
            paint.Style = SKPaintStyle.Fill;
            //paint.ColorFilter = colorFilter;
            canvas.Clear(backColor);
            //paint.Color = reverseBlack ? SKColors.White: SKColors.Black;
            var dest = new SKRect(0, 0, prnWidth, nHeight);
            canvas.DrawBitmap(bmp, dest, paint);
        }
        bmp = bmp1;
        ///var ratio = 96.0f / 25.4f;
        //size = new SKSize((int)Math.Round(bmp.Width * ratio), (int)Math.Round(bmp.Height * ratio));
        size = new SKSize(bmp.Width, bmp.Height);
        //
        var stride = bmp.RowBytes;
        var width = bmp.Width;
        var pixelLen = stride / width;
        var height = bmp.Height;
        int bytes = Math.Abs(stride) * height;
        //var raw = new byte[bytes];
        IntPtr ptr = bmp.GetPixels();
        //Marshal.Copy(ptr, raw, 0, bytes);
        //var data = new List<byte>();
        // Start Send Lines
        byte[,] dots = new byte[width, height];
        var threshold = 127;
        byte black = 0x1;
        byte white = 0x0;
        if (reverseBlack)
        {
            black = 0x0;
            white = 0x1;
        }
        unsafe
        {
            var pTarget = (uint*)ptr.ToPointer();
            for (int y = 0; y < bmp.Height; y++)
            {
                var rowOffset = y * bmp.Width;
                for (int x = 0; x < bmp.Width; x++)
                {
                    uint c1 = *pTarget;
                    byte[] bites = BitConverter.GetBytes(c1);
                    byte gray;
                    //gray = (byte)(0.299 * bites[0] + 0.587 * bites[1] + 0.114 * bites[2]);
                    gray = (byte)Math.Round((bites[0] + bites[1] + bites[2]) / 3.0);
                    var c2 = white;
                    if (gray < threshold) c2 = black;
                    dots[x, y] = c2;
                    pTarget += 1;
                }
            }
        }
    
        // Save Image
        //SKImage img1 = SKImage.FromBitmap(bmp1);
        //SKData encode1 = img1.Encode(SKEncodedImageFormat.Jpeg, 100);
        //MemoryStream? ms = new MemoryStream();
        //encode1.SaveTo(ms);
        //if (ms != null) CommunityToolkit.Maui.Storage.FileSaver.SaveAsync("BlackWhite.jpg", ms);
    
        //raw = null;
        // Transform bytes in bits
        var buffer = new byte[(width * height) / 8];
        var pos = 0;
        for (int iCol = height - 1; iCol >= 0; iCol -= 1)
        {
            // start: bytes and bits
            for (int iRow = 0; iRow < width; iRow += 8)
            {
                int prnPixel = dots[iRow, iCol] << 7;
                prnPixel += dots[iRow + 1, iCol] << 6;
                prnPixel += dots[iRow + 2, iCol] << 5;
                prnPixel += dots[iRow + 3, iCol] << 4;
                prnPixel += dots[iRow + 4, iCol] << 3;
                prnPixel += dots[iRow + 5, iCol] << 2;
                prnPixel += dots[iRow + 6, iCol] << 1;
                prnPixel += dots[iRow + 7, iCol] << 0;
                buffer[pos] = (byte)prnPixel;
                pos++;
            }
        }
        //var ms = new MemoryStream(buffer);
        //if (ms != null) CommunityToolkit.Maui.Storage.FileSaver.SaveAsync("binarydata.dat", ms);
        //var filename = System.IO.Path.Combine(FileSystem.CacheDirectory, "binarydata.dat");
        //File.WriteAllBytes(filename, buffer);
        return buffer;
    }

[]

Answer 2

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;

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

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 5

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.