Java 整合实现图片文字识别

方案	精度	速度	成本	适用场景
OCR云服务	★★★★★	★★★☆	按量付费	企业级、多格式需求
AI大模型	★★★★☆	★★☆	高价	语义理解、非结构化内容
Tesseract	★★★☆	★★★☆	免费	离线、简单文档
PaddleOCR	★★★★☆	★★★★	免费	本地化、中英文混合场景

推荐选择：

快速上线选OCR云服务；
重隐私/离线选PaddleOCR；
简单需求选Tesseract；
复杂解析选AI大模型。

选择：

第三方OCR云服务按量收费，是愿意付费情况下的优选方案。
AI云服务按次收费，需要成本；本地部署，需要硬件条件；OCR识别文字，选择AI大材小用
Tesseract本地部署，开源免费。有许多项目都是选择的tesserate方案。
Paddle整合Java实现麻烦，识别效果感觉更好。我本次最终就是Paddle方案

三、实现

预处理:

待识别的图像可以先预处理再识别，会一定程度提高识别率

如：去噪、二值化、旋转校正等。

对于清晰的图像可以不做特殊处理，但是可能要做旋转处理

常用为【±5°、±10°、±90°、180°】

1、OpenCV

参考【在Java中使用OpenCV】这篇博文下载配置OpenCV，我选择的版本为4.0.0

OpenCV 图像工具类，旋转、灰度、二值化，按照需求添加处理

/** OpenCV工具类，主要做图片旋转、一般预处理*/
import org.opencv.core.*;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import org.springframework.lang.NonNull;

import java.io.FileNotFoundException;

public class OpencvUtil {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }

    /**
     * 旋转图像并保存
     *
     * @param inputPath  输入图像路径
     * @param outputPath 输出图像路径
     * @param angle      旋转角度（支持任意角度）
     */
    public static void rotateAndSaveImage(@NonNull String inputPath, @NonNull String outputPath, double angle) {
        // 读取图像
        Mat src = Imgcodecs.imread(inputPath);
        if (src.empty()) {
            System.err.println("无法加载图像: " + inputPath);
            return;
        }

        // 旋转图像
        Mat rotated = rotateImage(src, angle);

        // 保存图像
        boolean success = Imgcodecs.imwrite(outputPath, rotated);
        if (success) {
            System.out.println("图像已保存至: " + outputPath);
        } else {
            System.err.println("图像保存失败");
        }

        // 释放资源
        src.release();
        rotated.release();
    }

    /**
     * 读取指定路径的图像并按给定角度旋转
     *
     * @param inputPath 输入图像的文件路径
     * @param angle     旋转角度（支持任意角度）
     * @return 旋转后的图像矩阵(Mat对象)，若读取失败则返回null
     */
    public static Mat getRotateImageMat(@NonNull String inputPath, double angle) throws FileNotFoundException {
        // 读取图像
        Mat src = Imgcodecs.imread(inputPath);
        if (src.empty()) {
            throw new FileNotFoundException("路径:" + inputPath);
        }
        // 旋转图像
        return rotateImage(src, angle);
    }

    /**
     * 图像预处理优化 - 仅转换为白底黑字（适合 OCR）
     */
    public static Mat preprocessForOCR(@NonNull Mat src) {
        // 1. 转换为灰度图
        Mat gray = new Mat();
        Imgproc.cvtColor(src, gray, Imgproc.COLOR_BGR2GRAY);

        // 2. 自适应二值化（直接得到白底黑字）
        Mat binary = new Mat();
        Imgproc.adaptiveThreshold(gray, binary, 255,
                Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,
                Imgproc.THRESH_BINARY, 61, 9); // THRESH_BINARY 表示白底黑字

        // 释放资源
        gray.release();

        return binary;
    }


    /**
     * 图像旋转逻辑
     */
    private static Mat rotateImage(Mat src, double angle) {
        try {
            // 处理90倍数旋转（高效方法）
            if (angle == 90) {
                Mat rotated = new Mat();
                Core.rotate(src, rotated, Core.ROTATE_90_CLOCKWISE);
                return rotated;
            } else if (angle == -90 || angle == 270) {
                Mat rotated = new Mat();
                Core.rotate(src, rotated, Core.ROTATE_90_COUNTERCLOCKWISE);
                return rotated;
            } else if (angle == 180) {
                Mat rotated = new Mat();
                Core.rotate(src, rotated, Core.ROTATE_180);
                return rotated;
            }

            angle = -angle;
            // 任意角度旋转（使用仿射变换）
            Point center = new Point(src.cols() / 2.0, src.rows() / 2.0);
            Mat rotationMatrix = Imgproc.getRotationMatrix2D(center, angle, 1.0);

            // 计算旋转后的边界
            double radians = Math.toRadians(angle);
            double sin = Math.abs(Math.sin(radians));
            double cos = Math.abs(Math.cos(radians));
            int newWidth = (int) (src.cols() * cos + src.rows() * sin);
            int newHeight = (int) (src.cols() * sin + src.rows() * cos);

            // 调整变换矩阵以包含平移
            rotationMatrix.put(0, 2, rotationMatrix.get(0, 2)[0] + (newWidth - src.cols()) / 2.0);
            rotationMatrix.put(1, 2, rotationMatrix.get(1, 2)[0] + (newHeight - src.rows()) / 2.0);

            Mat rotated = new Mat();
            Imgproc.warpAffine(
                    src, rotated, rotationMatrix,
                    new Size(newWidth, newHeight),
                    Imgproc.INTER_LINEAR,
                    Core.BORDER_CONSTANT,
                    new Scalar(255, 255, 255) // 白色背景填充
            );

            rotationMatrix.release();
            return rotated;
        } finally {
            src.release();
        }
    }

    public static void main(String[] args) throws FileNotFoundException {
        String fileUrl = "C:\\Users\\28433\\Desktop\\id_card_demo.png";
        String fileOutUrl = "C:\\Users\\28433\\Desktop\\id_card_demo_out.png";

        //读取旋转后的图片
        Mat rotateImage = OpencvUtil.getRotateImageMat(fileUrl, 30);

        //可做预处理
        Mat preprocessedMat = OpencvUtil.preprocessForOCR(rotateImage);

        //保存处理后的图片
        Imgcodecs.imwrite(fileOutUrl, preprocessedMat);
    }

}

2、Java jdk 自带Java 2D API

Jdk版本图像工具类无需其他依赖，提供旋转、灰度、二值化处理

/** Jdk自带处理图像 工具类 */
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

/**
 * 图像工具类，提供围绕图像中心的任意角度旋转功能，
 */
public class ImageUtil {

    /**
     * 将指定路径的图像进行旋转并返回字节输出流
     *
     * @param inFilePath 输入图像路径
     * @param angle     旋转角度（支持任意角度）
     * @return 处理后的图像字节输出流
     * @throws IOException 图像读取/处理异常
     */
    public static ByteArrayOutputStream rotateImageAndGetStream(String inFilePath, double angle) throws IOException {
        // 读取图像
        BufferedImage originalImage = getBufferedImageFromFilePath(inFilePath);

        // 获取旋转后的图像
        BufferedImage rotatedImage = getRotateBufferedImage(originalImage, angle);

        ByteArrayOutputStream outputStream = getByteArrayOutputStreamFromImage(inFilePath, rotatedImage);
        return outputStream;
    }


    /**
     * 将图像保存到指定路径
     *
     * @param outFilePath   输出文件路径
     * @param rotatedImage 旋转后的图像对象
     * @throws IOException 如果图像保存失败则抛出异常
     */
    private static void saveImageToOutFilePath(String outFilePath, BufferedImage rotatedImage) throws IOException {
        String formatName = getFormatName(outFilePath); // 根据输出文件获取格式名称
        File outputFile = new File(outFilePath);
        boolean success = ImageIO.write(rotatedImage, formatName, outputFile);
        if (!success) {
            throw new IOException("图像保存失败");
        }
    }

    private static BufferedImage getBufferedImageFromFilePath(String inFilePath) throws IOException {
        // 读取图像
        File inputFile = new File(inFilePath);
        BufferedImage originalImage = ImageIO.read(inputFile);
        if (originalImage == null) {
            throw new IOException("无法加载图像: " + inFilePath);
        }
        return originalImage;
    }

    /**
     * 使用 AffineTransform 实现任意角度图像旋转
     *
     * @param bufferedImage 原始图像
     * @param angle 旋转角度
     * @return 旋转后的图像
     */
    /**
     * 使用 AffineTransform 实现任意角度图像旋转
     *
     * @param bufferedImage 原始图像
     * @param angle         旋转角度
     * @return 旋转后的图像
     */
    private static BufferedImage getRotateBufferedImage(BufferedImage bufferedImage, double angle) {
        double radians = Math.toRadians(angle);

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

        double sin = Math.abs(Math.sin(radians));
        double cos = Math.abs(Math.cos(radians));

        int newWidth = (int) Math.floor(width * cos + height * sin);
        int newHeight = (int) Math.floor(width * sin + height * cos);

        // 防止无效尺寸
        if (newWidth <= 0 || newHeight <= 0) {
            throw new IllegalArgumentException("Invalid rotation dimensions: " + newWidth + "x" + newHeight);
        }

        // 转换为标准图像类型（避免 TYPE_CUSTOM）
        BufferedImage sourceImage = new BufferedImage(
                width,
                height,
                BufferedImage.TYPE_INT_ARGB
        );
        Graphics2D g2 = sourceImage.createGraphics();
        g2.drawImage(bufferedImage, 0, 0, null);
        g2.dispose();

        // 创建仿射变换
        AffineTransform transform = new AffineTransform();
        transform.translate((newWidth - width) / 2.0, (newHeight - height) / 2.0);
        transform.rotate(radians, width / 2.0, height / 2.0); // 绕原图中心旋转

        // 创建目标图像
        BufferedImage rotatedImage = new BufferedImage(
                newWidth,
                newHeight,
                BufferedImage.TYPE_INT_ARGB
        );

        // 执行旋转操作
        AffineTransformOp op = new AffineTransformOp(transform, AffineTransformOp.TYPE_BILINEAR);
        return op.filter(sourceImage, rotatedImage);
    }
    

    /**
     * 将图像转换为灰度图
     *
     * @param originalImage 原始图像
     * @return 灰度图像
     */
    private static BufferedImage getGrayscaleBufferedImage(BufferedImage originalImage) {
        BufferedImage grayscaleImage = new BufferedImage(
                originalImage.getWidth(),
                originalImage.getHeight(),
                BufferedImage.TYPE_BYTE_GRAY
        );
        Graphics2D g2d = grayscaleImage.createGraphics();
        g2d.drawImage(originalImage, 0, 0, null);
        g2d.dispose();
        return grayscaleImage;
    }

    /**
     * 自适应二值化（局部均值法）
     *
     * // block size 越大越模糊，C 是偏移量（建议取值 5~15）
     * BufferedImage binaryImage = adaptiveBinarize(grayImage, 15, 10)
     */
    private static BufferedImage adaptiveBinarize(BufferedImage grayImage, int blockSize, int C) {
        int width = grayImage.getWidth();
        int height = grayImage.getHeight();
        BufferedImage binaryImage = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);

        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int sum = 0, count = 0;
                for (int dy = -blockSize / 2; dy <= blockSize / 2; dy++) {
                    for (int dx = -blockSize / 2; dx <= blockSize / 2; dx++) {
                        int nx = x + dx;
                        int ny = y + dy;
                        if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
                            int rgb = grayImage.getRGB(nx, ny);
                            int r = (rgb >> 16) & 0xFF;
                            sum += r;
                            count++;
                        }
                    }
                }
                int mean = sum / count;
                int threshold = mean - C;
                int r = (grayImage.getRGB(x, y) >> 16) & 0xFF;
                int binaryValue = (r < threshold) ? 0 : 255;
                binaryImage.setRGB(x, y, (binaryValue << 16) | (binaryValue << 8) | binaryValue);
            }
        }

        return binaryImage;
    }



    private static ByteArrayOutputStream getByteArrayOutputStreamFromImage(String inFilePath, BufferedImage rotatedImage) throws IOException {
        // 返回字节输出流
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        String formatName = getFormatName(inFilePath); // 根据输入文件获取格式名称
        ImageIO.write(rotatedImage, formatName, outputStream);
        return outputStream;
    }

    /**
     * 保存旋转后的图像到指定路径
     *
     * @param inFilePath  输入图像路径
     * @param outFilePath 输出图像路径
     * @param angle      旋转角度（支持任意角度）
     * @throws IOException 图像读取/写入异常
     */
    public static void rotateAndSaveImage(String inFilePath, String outFilePath, double angle) throws IOException {
        BufferedImage originalImage = getBufferedImageFromFilePath(inFilePath);

        // 获取旋转后的图像
        BufferedImage rotatedImage = getRotateBufferedImage(originalImage, angle);

        // 保存图像
        saveImageToOutFilePath(outFilePath, rotatedImage);
    }

    /**
     * 获取图像格式名称
     *
     * @param path 文件路径
     * @return 格式名称（如 "png", "jpg" 等）
     */
    private static String getFormatName(String path) {
        int dotIndex = path.lastIndexOf(".");
        if (dotIndex == -1 || dotIndex == path.length() - 1) {
            throw new IllegalArgumentException("无效的文件名，缺少扩展名");
        }
        return path.substring(dotIndex + 1);
    }

    public static void main(String[] args) throws IOException {
         String fileUrl = "C:\\Users\\28433\\Desktop\\id_card_demo.png";
         String fileTempUrl = "C:\\Users\\28433\\Desktop\\id_card_demo_temp.png";
         String fileOutUrl = "C:\\Users\\28433\\Desktop\\id_card_demo_out.png";

         //获取bufferedImage
        BufferedImage bufferedImageFromFilePath = getBufferedImageFromFilePath(fileUrl);

        //旋转
        BufferedImage rotateBufferedImage = getRotateBufferedImage(bufferedImageFromFilePath, 30);

        //灰度
        BufferedImage grayscaleBufferedImage = getGrayscaleBufferedImage(rotateBufferedImage);

        //二值化
        BufferedImage bufferedImage = adaptiveBinarize(grayscaleBufferedImage, 15, 10);

        //保存
        saveImageToOutFilePath(fileOutUrl,bufferedImage);
    }
}

识别:

1、Tesseract

参考【Tesseract OCR 的使用】，安装时，Additional language data (download) 不要勾选，【存在网络问题】就会无法下载附加训练语言包，安装失败，所以正常安装时不要勾选。默认带有eng训练文件，识别英文。需要识别简体中文，自己网上找chi_sim的训练文件放到tessdata目录下
识别效果一般，对某些字符识别不清，模糊或者倾斜图片识别乱码，需要自己训练。