在Android中对图像进行二值化

5
我正在开发一个使用Tesseract OCR从图像中扫描文本的Android应用程序,我听说在对其执行OCR之前对图像进行二值化处理会获得更好的结果,因此我开始寻找可以执行此操作的代码。
我找到了一些Java代码,但它们需要AWT库......因此它们不能在Android上工作。你能帮我找到一个吗?谢谢。

Firas habibi,类似这样的东西有用吗?http://imageshack.us/photo/my-images/7/binarize.png/ - Sherif elKhatib
是的,实际上我的很简单,它只是一个文本图像,因为我的项目是OCR文本。 - Firas Al Mannaa
和代码 Habibi :-) - Firas Al Mannaa
7个回答

6

我需要为一个项目任务完成类似的任务。在我的工作区中,我找到了这段代码,我认为这是您需要的:

Bitmap img = BitmapFactory.decodeResource(this.getResources(), drawable.testimage);
Paint paint = new Paint();

ColorMatrix cm = new ColorMatrix();
float a = 77f;
float b = 151f;
float c = 28f;
float t = 120 * -256f;
cm.set(new float[] { a, b, c, 0, t, a, b, c, 0, t, a, b, c, 0, t, 0, 0, 0, 1, 0 });
paint.setColorFilter(new ColorMatrixColorFilter(cm));
canvas.drawBitmap(img, 0, 0, paint);

在这里,我使用ColorMatrix从彩色图像中生成黑白图像。此外,我找到了以下这段代码,用于将彩色图像转换为灰度图像:

Bitmap result = Bitmap.createBitmap(destWidth, destHeight,Bitmap.Config.RGB_565);
RectF destRect = new RectF(0, 0, destWidth, destHeight);
Canvas canvas = new Canvas(result);
Paint paint = new Paint();
ColorMatrix colorMatrix = new ColorMatrix();
colorMatrix.setSaturation(0);
ColorFilter filter = new ColorMatrixColorFilter(colorMatrix);
paint.setColorFilter(filter);
canvas.drawBitmap(bitmap, sourceRect, destRect, paint); 

希望这能帮到你。

有什么问题吗?也许我可以帮你解决它。 - Diego
也许我做错了,但是我应该同时使用你上面给出的两个代码还是只用其中一个? - Firas Al Mannaa
2
其中只有第一个将图像img转换为黑白格式。请注意,第一行假定您的资源中有一个名为testimage的图像。您需要替换第一行以加载自己的图像。第二段代码将图像转换为灰度。同样,您需要加载自己的图像并从中获取宽度和高度(destWidth和destHeight)。如果您需要任何帮助,请告诉我。 - Diego
@Diego您好,我也在尝试在OCR处理之前对图像进行二值化,我想知道在哪里可以粘贴这段代码?我尝试将其放入我的代码中,但无法解决“canvas”符号。我正在运行Android Studio 1.5.1。 - Donovan Tan

4

简单的解决方案

以下实现中,我基于普通的三维空间距离公式修改了每个像素点。对于每个像素点,根据它离黑白两种颜色的距离来决定它应该是黑色还是白色。例如,(1,2,3) 离 (0,0,0) 比离 (255,255,255) 更近,因此被决定为黑色。当然,可能还有更巧妙的算法存在。这只是一个简单的方法。

MainActivity.java

package com.example.binarizeimage;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Environment;
import android.widget.ImageView;

import com.example.binarizeimage.R.drawable;

/**
 * @author Sherif elKhatib - shush
 *
 */
public class MainActivity extends Activity {
    /**
     * Boolean that tells me how to treat a transparent pixel (Should it be black?)
     */
    private static final boolean TRASNPARENT_IS_BLACK = false;
    /**
     * This is a point that will break the space into Black or white
     * In real words, if the distance between WHITE and BLACK is D;
     * then we should be this percent far from WHITE to be in the black region.
     * Example: If this value is 0.5, the space is equally split.  
     */
    private static final double SPACE_BREAKING_POINT = 13.0/30.0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //this is the original image
        Bitmap theOriginalImage = BitmapFactory.decodeResource(this.getResources(), drawable.ic_launcher);
        //this is the image that is binarized
        Bitmap binarizedImage = convertToMutable(theOriginalImage);
        // I will look at each pixel and use the function shouldBeBlack to decide 
        // whether to make it black or otherwise white
        for(int i=0;i<binarizedImage.getWidth();i++) {
            for(int c=0;c<binarizedImage.getHeight();c++) {
                int pixel = binarizedImage.getPixel(i, c);
                if(shouldBeBlack(pixel))
                    binarizedImage.setPixel(i, c, Color.BLACK);
                else
                    binarizedImage.setPixel(i, c, Color.WHITE);
            }
        }


        ImageView iv = (ImageView) findViewById(R.id.imageView1);
        ImageView ivb = (ImageView) findViewById(R.id.ImageView01);
        //show the original image
        iv.setImageBitmap(BitmapFactory.decodeResource(this.getResources(), drawable.ic_launcher));
        //show the binarized image
        ivb.setImageBitmap(binarizedImage);
    }
    /**
     * @param pixel the pixel that we need to decide on
     * @return boolean indicating whether this pixel should be black
     */
    private static boolean shouldBeBlack(int pixel) {
        int alpha = Color.alpha(pixel);
        int redValue = Color.red(pixel);
        int blueValue = Color.blue(pixel);
        int greenValue = Color.green(pixel);
        if(alpha == 0x00) //if this pixel is transparent let me use TRASNPARENT_IS_BLACK
            return TRASNPARENT_IS_BLACK;
        // distance from the white extreme
        double distanceFromWhite = Math.sqrt(Math.pow(0xff - redValue, 2) + Math.pow(0xff - blueValue, 2) + Math.pow(0xff - greenValue, 2));
        // distance from the black extreme //this should not be computed and might be as well a function of distanceFromWhite and the whole distance
        double distanceFromBlack = Math.sqrt(Math.pow(0x00 - redValue, 2) + Math.pow(0x00 - blueValue, 2) + Math.pow(0x00 - greenValue, 2));
        // distance between the extremes //this is a constant that should not be computed :p
        double distance = distanceFromBlack + distanceFromWhite;
        // distance between the extremes
        return ((distanceFromWhite/distance)>SPACE_BREAKING_POINT);
    }
    /**
     * @author Derzu
     * 
     * @see https://dev59.com/B2855IYBdhLWcg3wbjvO#9194259
     * 
     * Converts a immutable bitmap to a mutable bitmap. This operation doesn't allocates
     * more memory that there is already allocated.
     * 
     * @param imgIn - Source image. It will be released, and should not be used more
     * @return a copy of imgIn, but muttable.
     */
    public static Bitmap convertToMutable(Bitmap imgIn) {
        try {
            //this is the file going to use temporally to save the bytes. 
            // This file will not be a image, it will store the raw image data.
            File file = new File(Environment.getExternalStorageDirectory() + File.separator + "temp.tmp");

            //Open an RandomAccessFile
            //Make sure you have added uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
            //into AndroidManifest.xml file
            RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");

            // get the width and height of the source bitmap.
            int width = imgIn.getWidth();
            int height = imgIn.getHeight();
            Config type = imgIn.getConfig();

            //Copy the byte to the file
            //Assume source bitmap loaded using options.inPreferredConfig = Config.ARGB_8888;
            FileChannel channel = randomAccessFile.getChannel();
            MappedByteBuffer map = channel.map(MapMode.READ_WRITE, 0, imgIn.getRowBytes()*height);
            imgIn.copyPixelsToBuffer(map);
            //recycle the source bitmap, this will be no longer used.
            imgIn.recycle();
            System.gc();// try to force the bytes from the imgIn to be released

            //Create a new bitmap to load the bitmap again. Probably the memory will be available. 
            imgIn = Bitmap.createBitmap(width, height, type);
            map.position(0);
            //load it back from temporary 
            imgIn.copyPixelsFromBuffer(map);
            //close the temporary file and channel , then delete that also
            channel.close();
            randomAccessFile.close();

            // delete the temp file
            file.delete();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } 

        return imgIn;
    }
}

*activity_main.xml*

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity" >

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/textView2"
        android:layout_centerHorizontal="true"
        android:text="Original Image" />

    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/textView1"
        android:layout_centerHorizontal="true"
        android:src="@drawable/ic_launcher" />

    <TextView
        android:id="@+id/TextView02"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/textView1"
        android:layout_below="@+id/imageView1"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="28dp"
        android:text="YES/NO Image" />

    <ImageView
        android:id="@+id/ImageView01"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/TextView02"
        android:layout_centerHorizontal="true"
        android:src="@drawable/ic_launcher" />

</RelativeLayout>

我会尝试并再次回来,谢谢你 HABIB ALBY。 - Firas Al Mannaa
嗨,我也在寻找解决方案。我该如何将图像实现到你的代码中呢?我尝试创建一个新项目,并将你的代码粘贴进去,但是当我运行它时,应用程序在设备上无法启动。或者你能看一下我的问题吗:http://stackoverflow.com/questions/35568362/binarize-image-before-ocr-scan? - Donovan Tan

2

我曾经做过一个与颜色有关的类似项目,只不过是在另一个平台上。

虽然可能有更好的算法,但我使用了一个函数(GetColorDistance)来计算两种颜色在3D RGB空间中的距离,使用勾股定理。 GetNewColor计算一个颜色是否更接近白色或黑色,然后相应地返回黑色或白色。最后,GetBitmapBinary函数处理位图上的像素并将它们转换为黑白。

private Bitmap GetBinaryBitmap(Bitmap bitmap_src)
    {
        Bitmap bitmap_new=bitmap_src.copy(bitmap_src.getConfig(), true);



    for(int x=0; x<bitmap_new.getWidth(); x++)
    {
        for(int y=0; y<bitmap_new.getHeight(); y++)
        {
            int color=bitmap_new.getPixel(x, y);
            color=GetNewColor(color);
            bitmap_new.setPixel(x, y, color);
        }
    }

    return bitmap_new;
}


private double GetColorDistance(int c1, int c2)
{
    int db=Color.blue(c1)-Color.blue(c2);
    int dg=Color.green(c1)-Color.green(c2);
    int dr=Color.red(c1)-Color.red(c2);


    double d=Math.sqrt(  Math.pow(db, 2) + Math.pow(dg, 2) +Math.pow(dr, 2)  );
    return d;
}

private int GetNewColor(int c)
{
    double dwhite=GetColorDistance(c,Color.WHITE);
    double dblack=GetColorDistance(c,Color.BLACK);

    if(dwhite<=dblack)
    {
        return Color.WHITE;

    }
    else
    {
        return Color.BLACK;
    }


}

您可以修改GetNewColor函数以获得在不同光密度下更好的结果。例如,您可以将dblack乘以1.5,使较暗的像素在黑暗环境中变为白色。


2

使用这些类,就像在Android应用程序中看到的那样,进行二值化。我建议您重用此核心库中的代码,并且您拥有完整的源代码,包括使用它的源代码。 - Sean Owen
我认为它在DecodeHandler.java类中,但我无法让代码实现它,因为代码太复杂了!! - Firas Al Mannaa
您不需要使用其他代码。PlanarYUVLuminanceSource将把图像数据读入适当的形式,然后HybridBinarzier将对其进行二值化处理。您可以得到一个抽象形式的图像,并可以随意处理它。实际上只需要这些类。 - Sean Owen

1

将此从Java移植到Android应该不太困难:

/**
 * Image binarization - Otsu algorithm
 *
 * Author: Bostjan Cigan (http://zerocool.is-a-geek.net)
 *
 */

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

public class OtsuBinarize {

    private static BufferedImage original, grayscale, binarized;

    public static void main(String[] args) throws IOException {

        File original_f = new File(args[0]+".jpg");
        String output_f = args[0]+"_bin";
        original = ImageIO.read(original_f);
        grayscale = toGray(original);
        binarized = binarize(grayscale);
        writeImage(output_f);         

    }

    private static void writeImage(String output) throws IOException {
        File file = new File(output+".jpg");
        ImageIO.write(binarized, "jpg", file);
    }

    // Return histogram of grayscale image
    public static int[] imageHistogram(BufferedImage input) {

        int[] histogram = new int[256];

        for(int i=0; i<histogram.length; i++) histogram[i] = 0;

        for(int i=0; i<input.getWidth(); i++) {
            for(int j=0; j<input.getHeight(); j++) {
                int red = new Color(input.getRGB (i, j)).getRed();
                histogram[red]++;
            }
        }

        return histogram;

    }

    // The luminance method
    private static BufferedImage toGray(BufferedImage original) {

        int alpha, red, green, blue;
        int newPixel;

        BufferedImage lum = new BufferedImage(original.getWidth(), original.getHeight(), original.getType());

        for(int i=0; i<original.getWidth(); i++) {
            for(int j=0; j<original.getHeight(); j++) {

                // Get pixels by R, G, B
                alpha = new Color(original.getRGB(i, j)).getAlpha();
                red = new Color(original.getRGB(i, j)).getRed();
                green = new Color(original.getRGB(i, j)).getGreen();
                blue = new Color(original.getRGB(i, j)).getBlue();

                red = (int) (0.21 * red + 0.71 * green + 0.07 * blue);
                // Return back to original format
                newPixel = colorToRGB(alpha, red, red, red);

                // Write pixels into image
                lum.setRGB(i, j, newPixel);

            }
        }

        return lum;

    }

    // Get binary treshold using Otsu's method
    private static int otsuTreshold(BufferedImage original) {

        int[] histogram = imageHistogram(original);
        int total = original.getHeight() * original.getWidth();

        float sum = 0;
        for(int i=0; i<256; i++) sum += i * histogram[i];

        float sumB = 0;
        int wB = 0;
        int wF = 0;

        float varMax = 0;
        int threshold = 0;

        for(int i=0 ; i<256 ; i++) {
            wB += histogram[i];
            if(wB == 0) continue;
            wF = total - wB;

            if(wF == 0) break;

            sumB += (float) (i * histogram[i]);
            float mB = sumB / wB;
            float mF = (sum - sumB) / wF;

            float varBetween = (float) wB * (float) wF * (mB - mF) * (mB - mF);

            if(varBetween > varMax) {
                varMax = varBetween;
                threshold = i;
            }
        }

        return threshold;

    }

    private static BufferedImage binarize(BufferedImage original) {

        int red;
        int newPixel;

        int threshold = otsuTreshold(original);

        BufferedImage binarized = new BufferedImage(original.getWidth(), original.getHeight(), original.getType());

        for(int i=0; i<original.getWidth(); i++) {
            for(int j=0; j<original.getHeight(); j++) {

                // Get pixels
                red = new Color(original.getRGB(i, j)).getRed();
                int alpha = new Color(original.getRGB(i, j)).getAlpha();
                if(red > threshold) {
                    newPixel = 255;
                }
                else {
                    newPixel = 0;
                }
                newPixel = colorToRGB(alpha, newPixel, newPixel, newPixel);
                binarized.setRGB(i, j, newPixel); 

            }
        }

        return binarized;

    }

    // Convert R, G, B, Alpha to standard 8 bit
    private static int colorToRGB(int alpha, int red, int green, int blue) {

        int newPixel = 0;
        newPixel += alpha;
        newPixel = newPixel << 8;
        newPixel += red; newPixel = newPixel << 8;
        newPixel += green; newPixel = newPixel << 8;
        newPixel += blue;

        return newPixel;

    }

}

1
你可以使用Catalano框架,它很简单且有超过60个滤镜。

http://code.google.com/p/catalano-framework/

FastBitmap fb = new FastBitmap(bitmap);

Grayscale g = new Grayscale(fb);
g.applyInPlace(fb);

Threshold t = new Threshold(100);
t.applyInPlace(fb);

bitmap = fb.toBitmap();

1

简洁明了并且首要的步骤是将图像转换为灰度图(如果不转换,你将会得到一个输入图像错误) 转换完成后,使用自适应阈值方法来完成任务。 代码:

 Mat tmp = new Mat(bitmap.getWidth(), bitmap.getHeight(), CvType.CV_8UC1);
                // Convert
                Utils.bitmapToMat(bitmap, tmp);

                Mat gray = new Mat(bitmap.getWidth(), bitmap.getHeight(),     CvType.CV_8UC1);
                // Conver the color
                Imgproc.cvtColor(tmp, gray, Imgproc.COLOR_RGB2GRAY);
                // Convert back to bitmap


                Mat destination = new Mat(gray.rows(),gray.cols(),gray.type());

                Imgproc.adaptiveThreshold(gray, destination, 255,
                        Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY_INV, 15, 4);

                Utils.matToBitmap(destination, bitmap);
                imv_binary.setImageBitmap(bitmap);

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接