Java 计算2字节数组的欧氏距离

我有两个主要的图像，我想比较一组其他图像与他们。 我要做的是计算这两幅图像的字节数组，然后将这两幅图像与当前正在处理的图像进行比较。以下是两幅主要图像：

File upper = new File("sweater.jpg");
byte [] upperPart = Files.readAllBytes(upper.toPath());
File lower = new File("pants.jpg");
byte [] lowerPart = Files.readAllBytes(lower.toPath());

然后，在处理目录中所有图像的循环中，我执行以下操作：

byte [] currentImage = Files.readAllBytes(f.toPath());
float differenceUpper = 0;
float differenceLower = 0;
for (int i=0;i< currentImage.length;i++) {
    differenceUpper  += (upperPart[i] - currentImage[i])^2;
    differenceLower  += (lowerPart[i] - currentImage[i])^2;
}
float euclideanDistanceUpper = (float) Math.sqrt(differenceUpper);
float euclideanDistanceLower = (float) Math.sqrt(differenceLower);
if (euclideanDistanceUpper < euclideanDistanceLower){
    filename = filename + "Upper";
} else {
    filename = filename + "Lower";
}

图像大小都是一样的，所以我真的不明白为什么它适用于上层而不适用于下层。有什么提示吗？谢谢

更新

---

因此，基本上问题在于，即使图像大小相同，生成的字节数组大小也不相同。

关于分辨率，图像大小可能相同（例如，它们可能都是800x600像素）。但您不是在比较图像，而是在比较文件。而且。。。无论如何，以这种方式比较图像是没有意义的。大小为800x600的两个JPG图像文件的大小可能为10KB或50KB。它取决于图像内容和压缩级别

您（很可能…）想要做的是比较图像的像素。因此，您必须使用

ImageIO

读取图像，并解码JPG文件以获得实际的像素数据

您可以使用

BufferedImage upper = ImageIO.read(new File("upper.jpg"));
BufferedImage lower = ImageIO.read(new File("lower.jpg"));

然后，要比较图像，必须计算像素的差异。这不是小事。没有通用的、普遍适用的像素“距离度量”。一种简单的方法是对两幅图像的像素进行迭代，然后计算如下内容

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

获取红色、绿色、蓝色和alpha通道中的差值，并将这些差值相加，以获得稍后计算平方根的值

---

旁注：你算了

differenceUpper  += (upperPart[i] - currentImage[i])^2;

但是请注意，

^2

不会像您所期望的那样计算功率。您可以使用

Math.pow（difference，2）

，但最好使用类似

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

---

就分辨率而言，图像的大小可能相同（例如，它们可能都是800x600像素）。但您不是在比较图像，而是在比较文件。而且。。。无论如何，以这种方式比较图像是没有意义的。大小为800x600的两个JPG图像文件的大小可能为10KB或50KB。它取决于图像内容和压缩级别

您（很可能…）想要做的是比较图像的像素。因此，您必须使用

ImageIO

读取图像，并解码JPG文件以获得实际的像素数据

您可以使用

BufferedImage upper = ImageIO.read(new File("upper.jpg"));
BufferedImage lower = ImageIO.read(new File("lower.jpg"));

然后，要比较图像，必须计算像素的差异。这不是小事。没有通用的、普遍适用的像素“距离度量”。一种简单的方法是对两幅图像的像素进行迭代，然后计算如下内容

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

获取红色、绿色、蓝色和alpha通道中的差值，并将这些差值相加，以获得稍后计算平方根的值

---

旁注：你算了

differenceUpper  += (upperPart[i] - currentImage[i])^2;

但是请注意，

^2

不会像您所期望的那样计算功率。您可以使用

Math.pow（difference，2）

，但最好使用类似

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

---

就分辨率而言，图像的大小可能相同（例如，它们可能都是800x600像素）。但您不是在比较图像，而是在比较文件。而且。。。无论如何，以这种方式比较图像是没有意义的。大小为800x600的两个JPG图像文件的大小可能为10KB或50KB。它取决于图像内容和压缩级别

您（很可能…）想要做的是比较图像的像素。因此，您必须使用

ImageIO

读取图像，并解码JPG文件以获得实际的像素数据

您可以使用

BufferedImage upper = ImageIO.read(new File("upper.jpg"));
BufferedImage lower = ImageIO.read(new File("lower.jpg"));

然后，要比较图像，必须计算像素的差异。这不是小事。没有通用的、普遍适用的像素“距离度量”。一种简单的方法是对两幅图像的像素进行迭代，然后计算如下内容

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

获取红色、绿色、蓝色和alpha通道中的差值，并将这些差值相加，以获得稍后计算平方根的值

---

旁注：你算了

differenceUpper  += (upperPart[i] - currentImage[i])^2;

但是请注意，

^2

不会像您所期望的那样计算功率。您可以使用

Math.pow（difference，2）

，但最好使用类似

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

---

就分辨率而言，图像的大小可能相同（例如，它们可能都是800x600像素）。但您不是在比较图像，而是在比较文件。而且。。。无论如何，以这种方式比较图像是没有意义的。大小为800x600的两个JPG图像文件的大小可能为10KB或50KB。它取决于图像内容和压缩级别

您（很可能…）想要做的是比较图像的像素。因此，您必须使用

ImageIO

读取图像，并解码JPG文件以获得实际的像素数据

您可以使用

BufferedImage upper = ImageIO.read(new File("upper.jpg"));
BufferedImage lower = ImageIO.read(new File("lower.jpg"));

然后，要比较图像，必须计算像素的差异。这不是小事。没有通用的、普遍适用的像素“距离度量”。一种简单的方法是对两幅图像的像素进行迭代，然后计算如下内容

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

获取红色、绿色、蓝色和alpha通道中的差值，并将这些差值相加，以获得稍后计算平方根的值

---

旁注：你算了

differenceUpper  += (upperPart[i] - currentImage[i])^2;

但是请注意，

^2

不会像您所期望的那样计算功率。您可以使用

Math.pow（difference，2）

，但最好使用类似

int argb0 = image0.getRGB(x, y);
int argb1 = image1.getRGB(x, y);

int a0 = (argb0 >> 24) & 0xFF;
int r0 = (argb0 >> 16) & 0xFF;
int g0 = (argb0 >>  8) & 0xFF;
int b0 = (argb0      ) & 0xFF;

int a1 = (argb1 >> 24) & 0xFF;
int r1 = (argb1 >> 16) & 0xFF;
int g1 = (argb1 >>  8) & 0xFF;
int b1 = (argb1      ) & 0xFF;

int aDiff = Math.abs(a1 - a0);
int rDiff = Math.abs(r1 - r0);
int gDiff = Math.abs(g1 - g0);
int bDiff = Math.abs(b1 - b0);

differenceSum += difference * difference;

---

所有的图片大小都一样吗？相同大小的字节数组？所有图像的大小都相同。字节数组不是，我想当然地认为，如果图像大小相同，字节数组也会相同