Android：将位图转换为单色位图（每像素 1 位）

Question

我想将位图打印到移动蓝牙打印机 (Bixolon SPP-R200) - SDK 不提供打印内存中图像的直接方法。所以我考虑像这样转换位图：

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

转换为单色位图。我使用画布在上面给定的位图上绘制黑色文本，效果很好。但是，当我将上面的位图转换为 ByteArray 时，打印机似乎无法处理这些字节。我怀疑我需要一个每个像素一位的数组（一个像素要么是白色 = 1，要么是黑色 = 0）。

由于似乎没有方便的、开箱即用的方法来做到这一点，我的一个想法是使用：

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

获取像素。我想，我必须按如下方式使用它：

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

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

但是 - 我不确定一些事情：

• 在 getPixels 中 - 简单地将宽度作为“Stride”参数传递是否有意义？
• 我想我必须评估每个像素的颜色信息并将其切换为黑色或白色（并且我会将这个值写入一个新的目标字节数组中，最终将其传递给打印机）？
• 如何最好地评估每个像素的颜色信息，以决定它应该是黑色还是白色？ （渲染的位图是白色背景上的黑色痛苦）

这种方法有意义吗？有更简单的方法吗？仅将位图设为黑色和黑色是不够的。白色，主要问题是将每个像素的颜色信息减少为一位。

更新

根据 Reuben 的建议，我首先将位图转换为单色位图。然后我将迭代每个像素：

    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);
        }
    }

现在 Reuben 建议“读取每个 32 位像素的最低字节”——这与我关于如何评估像素颜色的问题有关。我在这方面的最后一个问题：我是否可以通过简单地这样做来获得最低字节：

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

Answer 1

您可以使用 ColorMatrix 将图像转换为单色 32bpp。

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);

这简化了彩色→单色转换。现在您只需执行 getPixels() 并读取每个 32 位像素的最低字节。如果<128则为0，否则为1。

Answer 2

好吧，我认为现在回复这个帖子已经很晚了，但我有时也在研究这些东西，并决定构建我自己的库，将任何 jpg 或 png 图像转换为 1bpp .bmp。大多数需要 1bpp 图像的打印机都支持此图像（已在其中之一上进行测试:)）。
在这里您可以找到库以及使用它来制作单色单通道图像的测试项目。请随意更改它..:)

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

享受..!! :)

Answer 3

您应该将每个像素转换为 HSV 空间，并使用该值来确定目标图像上的像素应该是黑色还是白色：

  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 4

转换为与原始位图大小完全相同的单色不足以进行打印。

打印机只能将每个“像素”（点）打印为单色，因为每个墨水点只有一种颜色，因此它们必须使用足够多的点并调整其大小、密度……以模拟灰度般的感觉。这种技术称为半色调。您可以看到，打印机的分辨率通常至少为 600dpi，通常为 1200-4800dpi，而显示屏的分辨率通常最高为 200-300ppi。

所以你的单色位图应该是 <每侧至少为原始分辨率的 3 倍。

Answer 5

我认为保留颜色会产生更好的 1 位像素图像；我已经评论了高对比度滤镜和灰色矩阵，如果想尝试的话。

我没有对速度进行基准测试，目标是将数据发送到 POS 打印机，

如果您在图像上添加 BMP 标头（62 字节）前缀，则 96 像素（屏幕）可以转换为 203 像素（打印机），也许可以转换为 BMP 格式。

我将 C# 与 SkiaSharp 一起使用，但对于 java 代码也很有用。

    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;
    }

[]