java图像识别工具类(ImageRecognitionUtils)使用实例详解

<dependency>
    <groupId>org.openpnp</groupId>
    <artifactId>opencv</artifactId>
    <version>4.5.1-2</version>
</dependency>

import org.opencv.core.Core;

public class ImageRecognitionUtils {

    static {
        // 加载 OpenCV 本地库
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
}

import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;

public class ImageRecognitionUtils {

    /**
     * 加载图像文件
     *
     * @param imagePath 图像文件路径
     * @return Mat 对象，表示图像矩阵
     */
    public static Mat loadImage(String imagePath) {
        return Imgcodecs.imread(imagePath);
    }

    /**
     * 保存图像到文件
     *
     * @param image Mat 对象
     * @param outputPath 输出文件路径
     */
    public static void saveImage(Mat image, String outputPath) {
        Imgcodecs.imwrite(outputPath, image);
    }
}

import org.opencv.dnn.Dnn;
import org.opencv.dnn.Net;
import org.opencv.core.Mat;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;

public class ImageRecognitionUtils {

    private Net net;

    /**
     * 加载预训练模型
     *
     * @param modelPath 模型文件路径
     * @param configPath 模型配置文件路径（可选）
     */
    public void loadModel(String modelPath, String configPath) {
        this.net = Dnn.readNet(modelPath, configPath);
    }

    /**
     * 对图像进行分类
     *
     * @param image 要分类的图像
     * @return 分类结果
     */
    public String classifyImage(Mat image) {
        if (net == null) {
            throw new IllegalStateException("模型尚未加载");
        }

        // 将图像转换为深度学习模型的输入格式
        Mat blob = Dnn.blobFromImage(image, 1.0, new Size(224, 224), new Scalar(0, 0, 0), false, false);
        net.setInput(blob);

        // 执行前向传递，获取分类结果
        Mat output = net.forward();

        // 假设分类器输出是一个概率分布（可根据模型调整）
        int classId = getMaxClass(output);
        return "类别ID: " + classId;
    }

    // 获取最大概率的类别
    private int getMaxClass(Mat output) {
        float[] data = new float[(int) output.total()];
        output.get(0, 0, data);
        int maxIdx = -1;
        float maxVal = -Float.MAX_VALUE;
        for (int i = 0; i < data.length; i++) {
            if (data[i] > maxVal) {
                maxVal = data[i];
                maxIdx = i;
            }
        }
        return maxIdx;
    }
}

import org.opencv.objdetect.CascadeClassifier;
import org.opencv.core.MatOfRect;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Point;
import org.opencv.imgproc.Imgproc;

public class ImageRecognitionUtils {

    private CascadeClassifier faceCascade;

    /**
     * 加载人脸检测分类器
     *
     * @param classifierPath 分类器 XML 文件路径
     */
    public void loadFaceClassifier(String classifierPath) {
        this.faceCascade = new CascadeClassifier(classifierPath);
    }

    /**
     * 检测图像中的人脸并返回检测结果
     *
     * @param image 输入图像
     * @return 人脸检测到的矩形框列表
     */
    public MatOfRect detectFaces(Mat image) {
        if (faceCascade == null) {
            throw new IllegalStateException("人脸检测分类器尚未加载");
        }

        MatOfRect faceDetections = new MatOfRect();
        faceCascade.detectMultiScale(image, faceDetections);

        return faceDetections;
    }

    /**
     * 标记检测到的人脸
     *
     * @param image 输入图像
     * @param faces 人脸矩形框列表
     */
    public void markDetectedFaces(Mat image, MatOfRect faces) {
        for (Rect rect : faces.toArray()) {
            Imgproc.rectangle(image, new Point(rect.x, rect.y), 
                new Point(rect.x + rect.width, rect.y + rect.height), new Scalar(0, 255, 0));
        }
    }
}

import org.opencv.features2d.Features2d;
import org.opencv.features2d.ORB;
import org.opencv.core.MatOfKeyPoint;

public class ImageRecognitionUtils {

    private ORB orb;

    public ImageRecognitionUtils() {
        this.orb = ORB.create();
    }

    /**
     * 提取图像的关键特征点
     *
   VphpYPRON  * @param image 输入图像
     * @return 关键点矩阵
     */
    public MatOfKeyPoint extractKeyPoints(Mat image) {
        MatOfKeyPoint keyPoints = new MatOfKeyPoint();
        orb.detect(image, keyPoints);
        return keyPoints;
    }

    /**
     * 显示图像的特征点
     *
     * @param image 输入图像


     * @param keyPoints 关键点
     * @return 带有特征点的图像
     */
    public Mat drawKeyPoints(Mat image, MatOfKeyPoint keyPoints) {
        Mat outputImage = new Mat();
        Features2d.drawKeypoints(image, keyPoints, outputImage);
        return outputImage;
    }
}

public class Main {
    public static void main(String[] args) {
        String imagePath = "test.jpg";
        String classifierPath = "haarcascade_frontalface_default.xml";

        // 加载图像
        Mat image = ImageRecognitionUtils.loadImage(imagePath);

        // 创建工具类实例并加载人脸分类器
        ImageRecognitionUtils recognitionUtils = new ImageRecognitionUtils();
    编程    recognitionUtils.loadFaceClassifier(classifierPath);

        // 人脸检测
        MatOfRect faces = recognitionUtils.detectFaces(image);

        // 标记人脸
        recognitionUtils.markDetectedFaces(image, faces);

        // 保存检测结果
        ImageRecognitionUtils.saveImage(image, "output.jpg");

        // 提取特征点并显示
        MatOfKeyPoint keyPoints = recognitionUtils.extractKeyPoints(image);
        Mat outputImage = recognitionUtils.drawKeyPoints(image, keyPoints);
        ImageRecognitionUtils.saveImage(outputImage, "keypoints_output.jpg");
    }
}