使用Java语言 利用OpenCV，对两种图片相似度对比

下边是代码部分

import org.opencv.core.*;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import java.io.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import org.opencv.features2d.*;
import org.opencv.core.MatOfDMatch;
import org.opencv.core.DMatch;

public class OpenCVImageSimilarity {

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

// 加载OpenCV库

// 读取两张图像。准备比对的图片
System.loadLibrary(Core.NATIVE_LIBRARY_NAME); // 加载OpenCV库NATIVE_LIBRARY_NAME
String imageUrl1 = "https://img/0b653e8b-d306-4e15-8e64-4d2212a7434b.jpg";
String imageUrl2 = "https://img/98845b33-0237-45a1-a91d-714d6aba0c3c.jpg";

Mat image1 = readImageFromUrl(imageUrl1); // 调用方法读取网络图片
Mat image2 = readImageFromUrl(imageUrl2); double rdb=rdbSimilar(image1,image2);
double hash= meanHash(image1, image2);
double hist= histogram(image1, image2);
double result=(rdb+hash+hist)/ 3;
System.out.println("RDB相似度：" +rdb );
System.out.println("均值哈希算法计算相似度："+hash);
System.out.println("图片相似度(直方图): " + hist);

/* if (image1 != null) {
// 图片读取成功，可以进行后续处理或保存
// 这里只是示例将图片保存到本地
String outputPath = "output.jpg";
Imgcodecs.imwrite(outputPath, image1);
System.out.println("图片保存成功: " + outputPath);
} else {
System.out.println("图片读取失败");
}*/
// 将图片处理成一样大

// 计算归一化交叉相关（NCC）
// double ncc = calculateNCC(image1, image2);
// System.out.println("归一化交叉相关（NCC）: " + ncc);
}
private static Mat readImageFromUrl(String imageUrl) {
Mat image = null;
try {
// 使用URL类打开网络图片的输入流
URL url = new URL(imageUrl);
BufferedInputStream inputStream = new BufferedInputStream(url.openStream());

// 将输入流解码为OpenCV的Mat对象
byte[] imageData = inputStream.readAllBytes();
image = Imgcodecs.imdecode(new MatOfByte(imageData), Imgcodecs.IMREAD_COLOR);
} catch (IOException e) {
e.printStackTrace();
}
return image;
}
static double histogram(Mat image1, Mat image2){
Imgproc.resize(image1, image1, image2.size());
Imgproc.resize(image2, image2, image1.size());

// 计算均方差（MSE）
double mse = calculateMSE(image1, image2);
// System.out.println("均方差（MSE）: " + mse);

// 计算结构相似性指数（SSIM）
double ssim = calculateSSIM(image1, image2);
//System.out.println("结构相似性指数（SSIM）: " + ssim);

// 计算峰值信噪比（PSNR）
double psnr = calculatePSNR(image1, image2);
// System.out.println("峰值信噪比（PSNR）: " + psnr);

// 计算直方图
final double similarity = calculateHistogram(image1, image2);
// System.out.println("图片相似度(直方图): " + similarity);
return similarity;

}

// 计算均方差（MSE）
private static double calculateHistogram(Mat image1, Mat image2) {
// 计算直方图
Mat hist1 = calculateHistogram(image1);
Mat hist2 = calculateHistogram(image2);

// 计算相似度
final double similarity = Imgproc.compareHist(hist1, hist2, Imgproc.CV_COMP_CORREL);
return similarity;
}

// 计算均方差（MSE）
private static double calculateMSE(Mat image1, Mat image2) {
Mat diff = new Mat();
Core.absdiff(image1, image2, diff);
Mat squaredDiff = new Mat();
Core.multiply(diff, diff, squaredDiff);
Scalar mseScalar = Core.mean(squaredDiff);
return mseScalar.val[0];
}

// 计算结构相似性指数（SSIM）
private static double calculateSSIM(Mat image1, Mat image2) {
Mat image1Gray = new Mat();
Mat image2Gray = new Mat();
Imgproc.cvtColor(image1, image1Gray, Imgproc.COLOR_BGR2GRAY);
Imgproc.cvtColor(image2, image2Gray, Imgproc.COLOR_BGR2GRAY);
MatOfFloat ssimMat = new MatOfFloat();
Imgproc.matchTemplate(image1Gray, image2Gray, ssimMat, Imgproc.CV_COMP_CORREL);
Scalar ssimScalar = Core.mean(ssimMat);
return ssimScalar.val[0];
}

// 计算峰值信噪比（PSNR）
private static double calculatePSNR(Mat image1, Mat image2) {
Mat diff = new Mat();
Core.absdiff(image1, image2, diff);
Mat squaredDiff = new Mat();
Core.multiply(diff, diff, squaredDiff);
Scalar mseScalar = Core.mean(squaredDiff);
double mse = mseScalar.val[0];
double psnr = 10.0 * Math.log10(255.0 * 255.0 / mse);
return psnr;
}

// 计算归一化交叉相关（NCC）
// private static double calculateNCC(Mat image1, Mat image2) {
// Mat image1Gray = new Mat();
// Mat image2Gray = new Mat();
// Imgproc.cvtColor(image1, image1Gray, Imgproc.COLOR_BGR2GRAY);
// Imgproc.cvtColor(image2, image2Gray, Imgproc.COLOR_BGR2GRAY);
// MatOfInt histSize = new MatOfInt(256);
// MatOfFloat ranges = new MatOfFloat(0, 256);
// Mat hist1 = new Mat();
// Mat hist2 = new Mat();
//
// Core.normalize(hist1, hist1, 0, 1, Core.NORM_MINMAX);
// Core.normalize(hist2, hist2, 0, 1, Core.NORM_MINMAX);
// double ncc = Core.compareHist(hist1, hist2, Imgproc.CV_COMP_CORREL);
// return ncc;
// }

private static Mat calculateHistogram(Mat image) {
Mat hist = new Mat();

// 设置直方图参数
MatOfInt histSize = new MatOfInt(256);
MatOfFloat ranges = new MatOfFloat(0, 256);
MatOfInt channels = new MatOfInt(0);
List images = new ArrayList<>();
images.add(image);

// 计算直方图
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);

return hist;
}
static double rdbSimilar(Mat img1, Mat img2){
// 加载OpenCV库
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

// 读取两张图片
/* Mat img1 = Imgcodecs.imread("path/to/your/image1.jpg");
Mat img2 = Imgcodecs.imread("path/to/your/image2.jpg");*/

// 创建ORB特征检测器和描述子提取器
ORB orb = ORB.create();

// 检测图像中的特征点并计算描述子
MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
Mat descriptors1 = new Mat();
Mat descriptors2 = new Mat();
orb.detectAndCompute(img1, new Mat(), keypoints1, descriptors1);
orb.detectAndCompute(img2, new Mat(), keypoints2, descriptors2);

// 创建描述子匹配器
DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);

// 匹配描述子
MatOfDMatch matches = new MatOfDMatch();
matcher.match(descriptors1, descriptors2, matches);

// 计算匹配结果的相似度
double maxDist = 0;
double minDist = 100;
DMatch[] matchArray = matches.toArray();
for (int i = 0; i < matchArray.length; i++) {
double dist = matchArray[i].distance;
if (dist < minDist) {
minDist = dist;
}
if (dist > maxDist) {
maxDist = dist;
}
}

// 输出相似度
double v = 1 - minDist / maxDist;
//System.out.println("最小距离：" + minDist);
// System.out.println("最大距离：" + maxDist);
// System.out.println("RDB相似度：" +v );
return v;
}

static double meanHash(Mat img1, Mat img2){
Mat grayImg1 = new Mat();
Mat grayImg2 = new Mat();
Imgproc.cvtColor(img1, grayImg1, Imgproc.COLOR_BGR2GRAY);
Imgproc.cvtColor(img2, grayImg2, Imgproc.COLOR_BGR2GRAY);
// 缩放图像至固定大小
Size targetSize = new Size(8, 8);
Mat resizedImg1 = new Mat();
Mat resizedImg2 = new Mat();
Imgproc.resize(grayImg1, resizedImg1, targetSize);
Imgproc.resize(grayImg2, resizedImg2, targetSize);

// 计算均值哈希值
String hash1 = calculateMeanHash(resizedImg1);
String hash2 = calculateMeanHash(resizedImg2);

// 计算汉明距离并计算相似度
int hammingDistance = calculateHammingDistance(hash1, hash2);
double similarity = 1 - (double) hammingDistance / (targetSize.width * targetSize.height);

return similarity;
}

private static String calculateMeanHash(Mat image) {
double sum = 0;
int totalPixels = image.rows() * image.cols();

for (int i = 0; i < image.rows(); i++) {
for (int j = 0; j < image.cols(); j++) {
double pixelValue = image.get(i, j)[0];
sum += pixelValue;
}
}

double mean = sum / totalPixels;
StringBuilder hash = new StringBuilder();

for (int i = 0; i < image.rows(); i++) {
for (int j = 0; j < image.cols(); j++) {
double pixelValue = image.get(i, j)[0];
if (pixelValue >= mean) {
hash.append("1");
} else {
hash.append("0");
}
}
}

return hash.toString();
}

public static int hammingDistance2(int hash1, int hash2){

int num = hash1 ^ hash2;

int count = 0;

for(; num > 0; count++)

{

num &= (num - 1);

}

return count;

}
private static int calculateHammingDistance(String hash1, String hash2) {
int distance = 0;

for (int i = 0; i < hash1.length(); i++) {
if (hash1.charAt(i) != hash2.charAt(i)) {
distance++;
}
}

return distance;
}

}

下载opencv官方地址：https://opencv.org/releases/ 安装opencv参考地址：https://blog.csdn.net/star1210644725/article/details/131004810?csdn_share_tail={"type"%3A"blog"%2C"rType"%3A"article"%2C"rId"%3A"131004810"%2C"source"%3A"star1210644725"}

如果是linux环境：需要把System.loadLibrary(Core.NATIVE_LIBRARY_NAME); 注释掉。然后在类中加入静态方法 static { OpenCV.LoadShared(); }