Java结合OpenCV实现图形模板匹配实战教程

java -Djava.library.path=<opencv-native-library-path> -jar your_app.jar

public static Mat imread(String filename, int flags)

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
public class ImageReadExample {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    public static void main(String[] args) {
        String imagePath = "images/test.jpg";
        Mat image = Imgcodecs.imread(imagePath, Imgcodecs.IMREAD_COLOR);
        if (image.empty()) {
            System.out.println("无法加载图像！");
            return;
        }
        System.out.println("图像维度：" + image.rows() + "x" + image.cols());
        System.out.println("图像类型：" + image.type());
    }
}

graph TD
    A[原始图像] --> B[RGB/BGR图像]
    B --> C[转换为灰度图像]
    B --> D[转换为HSV图像]
    C --> E[图像处理]
    D --> E

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class ColorConversionExample {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    public static void main(String[] args) {
        Mat bgrImage = Imgcodecs.imread("images/test.jpg", Imgcodecs.IMREAD_COLOR);
        Mat grayImage = new Mat();
        Imgproc.cvtColor(bgrImage, grayImage, Imgproc.COLOR_BGR2GRAY);
        System.out.println("原始图像类型：" + bgrImage.type());
        System.out.println("灰度图像类型：" + grayImage.type());
    }
}

graph TD
    A[彩色图像] --> B[获取RGB像素值]
    B --> C[按公式计算灰度值]
    C --> D[生成灰度图像]

Imgproc.cvtColor(src, dst, Imgproc.COLOR_BGR2GRAY);

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.core.CvType;
public class ManualGrayExample {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    public static void main(String[] args) {
        Mat bgrImage = Imgcodecs.imread("images/test.jpg", Imgcodecs.IMREAD_COLOR);
        Mat manualGray = Mat.zeros(bgrImage.rows(), bgrImage.cols(), CvType.CV_8UC1);
        for (int i = 0; i < bgrImage.rows(); i++) {
            for (int j = 0; j < bgrImage.cols(); j++) {
                double[] pixel = bgrImage.get(i, j);
                double grayValue = 0.299 * pixel[0] + 0.587 * pixel[1] + 0.114 * pixel[2];
                manualGray.put(i, j, grayValue);
            }
        }
        System.out.println("手动灰度图像类型：" + manualGray.type());
    }
}

File file = new File("images/test.jpg");
if (!file.exists()) {
    System.out.println("文件不存在，请检查路径！");
    return;
}

System.out.println("图像类型：" + image.type());
System.out.println("图像通道数：" + image.channels());

graph TD
    A[Mat对象] --> B[行数]
    A --> C[列数]
    A --> D[通道数]
    A --> E[数据类型]

graph TD
    A[开始图像缩放] --> B{是否需要高质量缩放?}
    B -- 是 --> C[选择双三次插值]
    B -- 否 --> D{是否需要高速处理?}
    D -- 是 --> E[选择最近邻插值]
    D -- 否 --> F[选择双线性插值]
    C --> G[应用缩放]
    E --> G
    F --> G
    G --> H[结束]

Imgproc.resize(Mat src, Mat dst, Size dsize, double fx, double fy, int interpolation)

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class ImageResizeExample {
    static { System.loadLibrary(Core.NATIVE_LIBRARY_NAME); }
    public static void main(String[] args) {
        // 读取原始图像
        Mat src = Imgcodecs.imread("input.jpg");
        Mat dst = new Mat();
        // 设置缩放比例
        double scale = 0.5;
        // 执行图像缩放
        Imgproc.resize(src, dst, new Size(), scale, scale, Imgproc.INTER_LINEAR);
        // 保存缩放后的图像
        Imgcodecs.imwrite("output.jpg", dst);
        // 释放资源
        src.release();
        dst.release();
    }
}

// 假设src为原始图像
Mat resized = new Mat();
Imgproc.resize(src, resized, new Size(640, 640), 0, 0, Imgproc.INTER_LINEAR);

graph TD
    A[目标图像] --> B[滑动窗口]
    B --> C[模板图像]
    C --> D[计算相似度]
    D --> E{窗口是否到达图像右下角?}
    E -->|否| B
    E -->|是| F[输出匹配结果]

Mat source = Imgcodecs.imread("source.jpg");
Mat template = Imgcodecs.imread("template.jpg");
Mat result = new Mat();
// 调用OpenCV的matchTemplate方法
Imgproc.matchTemplate(source, template, result, Imgproc.TM_CCOEFF_NORMED);
// 找出最大匹配值的位置
Core.MinMaxLocResult mmr = Core.minMaxLoc(result);
Point matchLoc = mmr.maxLoc;

void matchTemplate(InputArray image, InputArray templ, OutputArray result, int method, InputArray mask = noArray());

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class TemplateMatching {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    public static void main(String[] args) {
        // 加载目标图像和模板图像
        Mat source = Imgcodecs.imread("target.jpg");
        Mat template = Imgcodecs.imread("template.jpg");
        // 图像灰度化处理
        Mat graySource = new Mat();
        Mat grayTemplate = new Mat();
        Imgproc.cvtColor(source, graySource, Imgproc.COLOR_BGR2GRAY);
        Imgproc.cvtColor(template, grayTemplate, Imgproc.COLOR_BGR2GRAY);
        // 创建结果矩阵
        Mat result = new Mat();
        int resultCols = source.cols() - template.cols() + 1;
        int resultRows = source.rows() - template.rows() + 1;
        result.create(resultRows, resultCols, Core.CV_32FC1);

        // 调用matchTemplate函数
        int matchMethod = Imgproc.TM_CCOEFF_NORMED; // 使用归一化相关系数匹配
        Imgproc.matchTemplate(graySource, grayTemplate, result, matchMethod);
        // 使用minMaxLoc获取最佳匹配位置
        double minVal = 0, maxVal = 0;
        Point minLoc = new Point(), maxLoc = new Point();
        Core.MinMaxLocResult mmRes = Core.minMaxLoc(result);
        minVal = mmRes.minVal;
        maxVal = mmRes.maxVal;
        minLoc = mmRes.minLoc;
        maxLoc = mmRes.maxLoc;
        // 根据匹配方法选择最佳位置
        Point matchLoc = matchMethod == Imgproc.TM_SQDIFF || matchMethod == Imgproc.TM_SQDIFF_NORMED ? minLoc : maxLoc;
        // 在原图上绘制矩形标记匹配区域
        Rect matchRect = new Rect(matchLoc.x, matchLoc.y, template.cols(), template.rows());
        Imgproc.rectangle(source, matchRect, new Scalar(0, 255, 0), 2);
        // 保存结果图像
        Imgcodecs.imwrite("result.jpg", source);
    }
}

graph TD
    A[加载目标图像] --> B[图像灰度化]
    B --> C[加载模板图像]
    C --> D[图像灰度化]
    D --> E[创建结果矩阵]
    E --> F[调用matchTemplate函数]
    F --> G[获取最佳匹配位置]
    G --> H[在原图上绘制匹配框]
    H --> I[保存结果图像]

// 裁剪模板图像
Mat croppedTemplate = new Mat(template, new Rect(50, 50, 100, 100));

// 图像归一化
Mat normalizedSource = new Mat();
Mat normalizedTemplate = new Mat();
Core.normalize(graySource, normalizedSource, 0, 255, Core.NORM_MINMAX, CvType.CV_8UC1);
Core.normalize(grayTemplate, normalizedTemplate, 0, 255, Core.NORM_MINMAX, CvType.CV_8UC1);

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.imgcodecs.Imgcodecs;
public class NCCExample {
    static {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
    public static void main(String[] args) {
        // 加载图像
        Mat image = Imgcodecs.imread("image.jpg", Imgcodecs.IMREAD_GRAYSCALE);
        Mat template = Imgcodecs.imread("template.jpg", Imgcodecs.IMREAD_GRAYSCALE);
        double ncc = computeNCC(image, template);
        System.out.println("NCC Score: " + ncc);
    }
    public static double computeNCC(Mat image, Mat template) {
        int tWidth = template.cols();
        int tHeight = template.rows();
        int iWidth = image.cols();
        int iHeight = image.rows();
        double sumT = 0, sumI = 0;
        int total = tWidth * tHeight;
        // 计算模板和图像对应区域的平均值
        for (int y = 0; y < tHeight; y++) {
            for (int x = 0; x < tWidth; x++) {
                double[] tVal = new double[1];
                double[] iVal = new double[1];
                template.get(y, x, tVal);
                image.get(y, x, iVal);
                sumT += tVal[0];
                sumI += iVal[0];
            }
        }
        double meanT = sumT / total;
        double meanI = sumI / total;
        double numerator = 0, denominatorT = 0, denominatorI = 0;
        for (int y = 0; y < tHeight; y++) {
            for (int x = 0; x < tWidth; x++) {
                double[] tVal = new double[1];
                double[] iVal = new double[1];
                template.get(y, x, tVal);
                image.get(y, x, iVal);
                double diffT = tVal[0] - meanT;
                double diffI = iVal[0] - meanI;
                numerator += diffT * diffI;
                denominatorT += diffT * diffT;
                denominatorI += diffI * diffI;
            }
        }
        return numerator / (Math.sqrt(denominatorT * denominatorI));
    }
}

public class SSDMSEExample {
    public static void main(String[] args) {
        Mat image = Imgcodecs.imread("image.jpg", Imgcodecs.IMREAD_GRAYSCALE);
        Mat template = Imgcodecs.imread("template.jpg", Imgcodecs.IMREAD_GRAYSCALE);
        double ssd = computeSSD(image, template);
        double mse = computeMSE(image, template);
        System.out.println("SSD Score: " + ssd);
        System.out.println("MSE Score: " + mse);
    }
    public static double computeSSD(Mat image, Mat template) {
        int width = template.cols();
        int height = template.rows();
        double sum = 0;
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                double[] tVal = new double[1];
                double[] iVal = new double[1];
                template.get(y, x, tVal);
                image.get(y, x, iVal);
                double diff = tVal[0] - iVal[0];
                sum += diff * diff;
            }
        }
        return sum;
    }
    public static double computeMSE(Mat image, Mat template) {
        int width = template.cols();
        int height = template.rows();
        int total = width * height;
        double sum = 0;
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                double[] tVal = new double[1];
                double[] iVal = new double[1];
                template.get(y, x, tVal);
                image.get(y, x, iVal);
                double diff = tVal[0] - iVal[0];
                sum += diff * diff;
            }
        }
        return sum / total;
    }
}

public class PyramidMatch {
    public static void main(String[] args) {
        Mat image = Imgcodecs.imread("image.jpg", Imgcodecs.IMREAD_GRAYSCALE);
        Mat template = Imgcodecs.imread("template.jpg", Imgcodecs.IMREAD_GRAYSCALE);
        // 构建图像金字塔（上采样）
        Mat pyrImage = new Mat();
        Imgproc.pyrDown(image, pyrImage);
        // 缩放模板
        Mat pyrTemplate = new Mat();
        Imgproc.resize(template, pyrTemplate, pyrImage.size());
        double score = computeNCC(pyrImage, pyrTemplate);
        System.out.println("NCC Score (Pyramid): " + score);
    }
}

graph TD
    A[加载原始图像] --> B[构建图像金字塔]
    B --> C[在每一层进行模板匹配]
    C --> D{是否匹配成功?}
    D -- 是 --> E[记录匹配位置]
    D -- 否 --> F[继续下一层]

import org.opencv.core.*;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
public class TemplateMatchingExample {
    public static void main(String[] args) {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        // 读取源图像和模板图像
        Mat source = Imgcodecs.imread("input.jpg");
        Mat template = Imgcodecs.imread("template.jpg");
        // 创建结果矩阵
        int resultWidth = source.cols() - template.cols() + 1;
        int resultHeight = source.rows() - template.rows() + 1;
        Mat result = new Mat(resultHeight, resultWidth, CvType.CV_32FC1);
        // 执行模板匹配
        Imgproc.matchTemplate(source, template, result, Imgproc.TM_CCOEFF_NORMED);
        // 使用minMaxLoc获取最佳匹配位置
        double[] minVal = new double[1];
        double[] maxVal = new double[1];
        Point[] minLoc = new Point[1];
        Point[] maxLoc = new Point[1];
        Core.minMaxLoc(result, minVal, maxVal, minLoc, maxLoc, new Mat());
        // 获取最佳匹配位置
        Point matchLoc = maxLoc[0];
        // 在原图上绘制矩形框标记匹配区域
        Rect rect = new Rect(matchLoc.x, matchLoc.y, template.cols(), template.rows());
        Imgproc.rectangle(source, rect, new Scalar(0, 255, 0), 2);
        // 保存结果图像
        Imgcodecs.imwrite("output.jpg", source);
    }
}

// 设置匹配阈值
double threshold = 0.8;
// 遍历结果矩阵，找出所有大于阈值的匹配位置
Mat thresholdMask = new Mat();
Core.compare(result, threshold, thresholdMask, Core.CMP_GT);
// 寻找所有匹配点
List<Point> points = new ArrayList<>();
MatOfPoint locations = new MatOfPoint();
Imgproc.findNonZero(thresholdMask, locations);
for (Point pt : locations.toArray()) {
    points.add(pt);
}
// 绘制所有匹配区域
for (Point pt : points) {
    Rect rect = new Rect(pt.x, pt.y, template.cols(), template.rows());
    Imgproc.rectangle(source, rect, new Scalar(0, 255, 0), 2);
}