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

        // 執(zhí)行前向傳遞，獲取分類結果
        Mat output = net.forward();

        // 假設分類器輸出是一個概率分布（可根據(jù)模型調整）
        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();
    }

    /**
     * 提取圖像的關鍵特征點
     *
     * @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);

        // 創(chuàng)建工具類實例并加載人臉分類器
        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");
    }
}