圖片相似度演算法java

1. java 如何對比兩張圖片的相似度

這是java的弱項，屬於純演算法范疇，應該沒有什麼辦法。
希望回答能給你帶來幫助~
如果滿意，請採納，如還有疑問，可繼續追問！
您也可以向我們團隊發出請求，會有更專業的人來為您解答！

2. Java如何從攝像頭獲取照片和本地圖片對比相似度，我目前做了一個從攝像頭自動拍照，可是在運行類的時

你好牛啊· 對比相似度我不懂，不過對你的調用攝像頭拍照很有興趣

3. java 對比圖片相似度的演算法。。說說想法也行

每張圖分成四塊，將每部分的圖片混成一種純色，對比這四個純色可以篩掉大部分的圖片

4. 圖像視頻相似度演算法

前段時間公司項目用到了語音識別,圖像識別,視頻識別等,其實不能說是識別,應該說是相似度對比吧,畢竟相似度對比還上升不了到識別哈,等以後有了更深的理解再來討論修改下!這次就當做一個總結吧!

其實它的原理就是一個把需要的特徵總結在一個指紋碼裡面,進行降維成指紋碼,假如個指紋碼一模一樣,那兩張圖片就想似了.下面有寫怎麼編譯成唯一標識,再用漢明距離計算兩個指紋碼的相似度.

圖片是採用phash演算法,一共分為四步吧.

1.將圖片縮放到16*16大小,這是我們選擇的合適的大小,假如寬高不一樣,直接將其壓到16*16,去掉細節,只保留宏觀;

2.圖片一共是16*16的,共256個像素,我們將圖片進行灰度化,灰度化就是只有黑白灰三種,從白到黑,一共分了255層;

3.灰度化之後將圖片進行DCT轉換(離散餘弦變化),因為為了識別有的圖片旋轉,這個DCT轉換是將圖片進行了一種壓縮演算法;

4.我們對這個演算法進行了優化,因為之前是計算像素的均值,我們為了更准確,我們取RGB,rgb一共分為255個像素,我們將255個像素分為16段,如果像素大於0-16記為0,17到32記為1,直到255,這樣就得到255位的二進制,這就是這張圖片的指紋碼.

得到唯一標識的指紋碼之後怎麼去計算像素度呢?

通過漢明距離比較兩個二進制距離,如果距離小於<10的話,我們就判定兩張圖片相似.如果兩個指紋碼(二進制)一模一樣,我們就判定兩個是一張圖片,或者類似;

視頻的話我們是通過ffmpeg(ff am pig),它是一個專門處理視頻的框架,可以從視頻中按針提取圖片.然後就按照圖片的相似度取對比了...

5. 如何使用Java實現屏幕找圖功能

測試代碼

[java] view plain
public static void main(String[] args) throws Exception {
findImage4FullScreen(ImageCognition.SIM_ACCURATE_VERY);
}

public static void findImage4FullScreen(int sim) throws Exception {
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
int w = (int) screenSize.getWidth();
int h = 200;

Robot robot = new Robot();
BufferedImage screenImg = robot.createScreenCapture(new Rectangle(0, 0,
w, h));//對屏幕指定范圍進行截圖，保存到BufferedImage中
OutputStream out = new FileOutputStream("data/images/screen.png");
ImageIO.write(screenImg, "png", out);//將截到的BufferedImage寫到本地

InputStream in = new FileInputStream("data/images/search.png");
BufferedImage searchImg = ImageIO.read(in);//將要查找的本地圖讀到BufferedImage

//圖片識別工具類
ImageCognition ic = new ImageCognition();

List<CoordBean> list = ic.imageSearch(screenImg, searchImg, sim);
for (CoordBean coordBean : list) {
System.out.println("找到圖片,坐標是" + coordBean.getX() + ","
+ coordBean.getY());

//標注找到的圖的位置
Graphics g = screenImg.getGraphics();
g.setColor(Color.BLACK);
g.drawRect(coordBean.getX(), coordBean.getY(),
searchImg.getWidth(), searchImg.getHeight());
g.setFont(new Font(null, Font.BOLD, 20));
g.drawString("←找到的圖片在這里",
coordBean.getX() + searchImg.getWidth() + 5,
coordBean.getY() + 10 + searchImg.getHeight() / 2);
out = new FileOutputStream("data/images/result.png");
ImageIO.write(screenImg, "png", out);
}
}

額外的類

CoordBean

package cn.xt.imgCongnition;

public class CoordBean {

private int x;
private int y;

/**
* 獲取x坐標
*
* @return x坐標
*/
public int getX() {
return x;
}

public void setX(int x) {
this.x = x;
}

/**
* 獲取y坐標
*
* @return
*/
public int getY() {
return y;
}

public void setY(int y) {
this.y = y;
}

}

RgbImageComparerBean

package cn.xt.imgCongnition;

/**
* RGB 相關，圖片相似度計算時使用
*
*/
public class RgbImageComparerBean {

/****** 顏色值數組，第一緯度為x坐標，第二緯度為y坐標 ******/
private int colorArray[][];

/*** 是否忽略此點，若為true，則不納入比較的像素行列。 ***/
private boolean ignorePx[][];

/**** 圖片的寬高 ****/
private int imgWidth;
private int imgHeight;

// 圖片的像素總數
private int pxCount;

/**
* 獲取圖像的二維數組組成
*
* @return 圖像的二維數組
*/
public int[][] getColorArray() {
return colorArray;
}

/**
* 要對比的像素總數,會自動篩選掉不對比的顏色
*
* @param pxCount
*/
public void setPxCount(int pxCount) {
this.pxCount = pxCount;
}

/**
* 設置顏色二維數組
*
* @param colorArray
* 顏色二維數組，一維為x軸，二維為y軸
*/
public void setColorArray(int[][] colorArray) {
this.colorArray = colorArray;
this.imgWidth = this.colorArray.length;
this.imgHeight = this.colorArray[0].length;
this.pxCount = this.imgWidth * this.imgHeight;
}

/**
* 是否忽略此點，若為true，則不納入像素比較行列。
*
* @return 具體x，y坐標的那個像素點
*/
public boolean[][] getIgnorePx() {
return ignorePx;
}

/**
* 是否忽略此點，若為true，則不納入像素比較行列。
*
* @param ignorePx
* 具體x，y坐標的那個像素點
*/
public void setIgnorePx(boolean[][] ignorePx) {
this.ignorePx = ignorePx;
}

/**
* 獲取圖像的寬度
*
* @return 圖像寬度
*/
public int getImgWidth() {
return imgWidth;
}

/**
* 獲取圖像的高度
*
* @return 圖像高度
*/
public int getImgHeight() {
return imgHeight;
}

/**
* 獲取圖像里像素的總數
*
* @return
*/
public int getPxCount() {
return pxCount;
}

}

6. 計算圖像相似度的演算法有哪些

SIM = Structural SIMilarity（結構相似性），這是一種用來評測圖像質量的一種方法。由於人類視覺很容易從圖像中抽取出結構信息,因此計算兩幅圖像結構信息的相似性就可以用來作為一種檢測圖像質量的好壞.

首先結構信息不應該受到照明的影響,因此在計算結構信息時需要去掉亮度信息,即需要減掉圖像的均值;其次結構信息不應該受到圖像對比度的影響,因此計算結構信息時需要歸一化圖像的方差;最後我們就可以對圖像求取結構信息了,通常我們可以簡單地計算一下這兩幅處理後的圖像的相關系數.

然而圖像質量的好壞也受到亮度信息和對比度信息的制約,因此在計算圖像質量好壞時,在考慮結構信息的同時也需要考慮這兩者的影響.通常使用的計算方法如下,其中C1,C2,C3用來增加計算結果的穩定性:
2u(x)u(y) + C1
L(X,Y) = ------------------------ ,u(x), u(y)為圖像的均值
u(x)^2 + u(y)^2 + C1

2d(x)d(y) + C2
C(X,Y) = ------------------------,d(x),d(y)為圖像的方差
d(x)^2 + d(y)^2 + C2

d(x,y) + C3
S(X,Y) = ----------------------,d(x,y)為圖像x,y的協方差
d(x)d(y) + C3

而圖像質量Q = [L(X,Y)^a] x [C(X,Y)^b] x [S(X,Y)^c]，其中a，b，c分別用來控制三個要素的重要性，為了計算方便可以均選擇為1，C1，C2，C3為比較小的數值，通常C1=(K1 x L)^2, C2=(K2 xL)^2, C3 = C2/2, K1 << 1, K2 << 1, L為像素的最大值(通常為255).
希望對你能有所幫助。

7. java版 opencv 圖像對比相似度怎麼實現

沒有專門的函數，你要自己寫 以前寫過一個，先轉HSV，只考慮HS兩維，再求顏色直方圖，最後根據兩個圖像對應直方圖上的距離就可以了，通過這個可以計算相似度

8. 相似圖片搜索的原理是怎樣的

2011年，Google把「相似圖片搜索」正式放上了首頁。你可以用一張圖片，搜索互聯網上所有與它相似的圖片。點擊搜索框中照相機的圖標。

有了50×50像素的黑白縮略圖，就等於有了一個50×50的0-1矩陣。矩陣的每個值對應原圖的一個像素，0表示黑色，1表示白色。這個矩陣就是一張圖片的特徵矩陣。

兩個特徵矩陣的不同之處越少，就代表兩張圖片越相似。這可以用」異或運算」實現（即兩個值之中只有一個為1，則運算結果為1，否則運算結果為0）。對不同圖片的特徵矩陣進行」異或運算」，結果中的1越少，就是越相似的圖片。

9. 圖片相似度判斷

1. https://zhuanlan.hu.com/p/68215900
為了得到兩張相似的圖片，在這里通過以下幾種簡單的計算方式來計算圖片的相似度：
直方圖計算圖片的相似度
通過哈希值，漢明距離計算
通過圖片的餘弦距離計算
通過圖片結構度量計算

二、哈希演算法計算圖片的相似度
圖像指紋：

圖像指紋和人的指紋一樣，是身份的象徵，而圖像指紋簡單點來講，就是將圖像按照一定的哈希演算法，經過運算後得出的一組二進制數字。

漢明距離：

假如一組二進制數據為101，另外一組為111，那麼顯然把第一組的第二位數據0改成1就可以變成第二組數據111，所以兩組數據的漢明距離就為1。簡單點說，漢明距離就是一組二進制數據變成另一組數據所需的步驟數，顯然，這個數值可以衡量兩張圖片的差異，漢明距離越小，則代表相似度越高。漢明距離為0，即代表兩張圖片完全一樣。

感知哈希演算法是一類演算法的總稱，包括aHash、pHash、dHash。顧名思義，感知哈希不是以嚴格的方式計算Hash值，而是以更加相對的方式計算哈希值，因為「相似」與否，就是一種相對的判定。

幾種hash值的比較：

aHash：平均值哈希。速度比較快，但是常常不太精確。
pHash：感知哈希。精確度比較高，但是速度方面較差一些。
dHash：差異值哈希。精確度較高，且速度也非常快

該演算法是基於比較灰度圖每個像素與平均值來實現。

aHash的hanming距離步驟：

先將圖片壓縮成8*8的小圖
將圖片轉化為灰度圖
計算圖片的Hash值，這里的hash值是64位，或者是32位01字元串
將上面的hash值轉換為16位的
通過hash值來計算漢明距離

def ahash(image):
# 將圖片縮放為8*8的
image = cv2.resize(image, (8, 8), interpolation=cv2.INTER_CUBIC)
# 將圖片轉化為灰度圖
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# s為像素和初始灰度值，hash_str為哈希值初始值
s = 0
# 遍歷像素累加和
for i in range(8):
for j in range(8):
s = s + gray[i, j]
# 計算像素平均值
avg = s / 64
# 灰度大於平均值為1相反為0，得到圖片的平均哈希值，此時得到的hash值為64位的01字元串
ahash_str = ''
for i in range(8):
for j in range(8):
if gray[i, j] > avg:
ahash_str = ahash_str + '1'
else:
ahash_str = ahash_str + '0'
result = ''
for i in range(0, 64, 4):
result += ''.join('%x' % int(ahash_str[i: i + 4], 2))
# print("ahash值：",result)
return result
2.感知哈希演算法（pHash）：

均值哈希雖然簡單，但是受均值影響大。如果對圖像進行伽馬校正或者進行直方圖均值化都會影響均值，從而影響哈希值的計算。所以就有人提出更健壯的方法，通過離散餘弦（DCT）進行低頻提取。

離散餘弦變換（DCT）是種圖像壓縮演算法，它將圖像從像素域變換到頻率域。然後一般圖像都存在很多冗餘和相關性的，所以轉換到頻率域之後，只有很少的一部分頻率分量的系數才不為0，大部分系數都為0（或者說接近於0）。Phash哈希演算法過於嚴格，不夠精確，更適合搜索縮略圖，為了獲得更精確的結果可以選擇感知哈希演算法，它採用的是DCT（離散餘弦變換）來降低頻率的方法。

pHash的hanming距離步驟：

縮小圖片：32 * 32是一個較好的大小，這樣方便DCT計算轉化為灰度圖
計算DCT：利用Opencv中提供的dct()方法，注意輸入的圖像必須是32位浮點型，所以先利用numpy中的float32進行轉換
縮小DCT：DCT計算後的矩陣是32 * 32，保留左上角的8 * 8，這些代表的圖片的最低頻率
計算平均值：計算縮小DCT後的所有像素點的平均值。
進一步減小DCT：大於平均值記錄為1，反之記錄為0.
得到信息指紋：組合64個信息位，順序隨意保持一致性。
最後比對兩張圖片的指紋，獲得漢明距離即可。

def phash(path):
# 載入並調整圖片為32*32的灰度圖片
img = cv2.imread(path)
img1 = cv2.resize(img, (32, 32),cv2.COLOR_RGB2GRAY)
​
# 創建二維列表
h, w = img.shape[:2]
vis0 = np.zeros((h, w), np.float32)
vis0[:h, :w] = img1
​
# DCT二維變換
# 離散餘弦變換，得到dct系數矩陣
img_dct = cv2.dct(cv2.dct(vis0))
img_dct.resize(8,8)
# 把list變成一維list
img_list = np.array().flatten(img_dct.tolist())
# 計算均值
img_mean = cv2.mean(img_list)
avg_list = ['0' if i<img_mean else '1' for i in img_list]
return ''.join(['%x' % int(''.join(avg_list[x:x+4]),2) for x in range(0,64,4)])

相比pHash，dHash的速度要快的多，相比aHash，dHash在效率幾乎相同的情況下的效果要更好，它是基於漸變實現的。

dHash的hanming距離步驟：

先將圖片壓縮成9*8的小圖，有72個像素點
將圖片轉化為灰度圖
計算差異值：dHash演算法工作在相鄰像素之間，這樣每行9個像素之間產生了8個不同的差異，一共8行，則產生了64個差異值，或者是32位01字元串。
獲得指紋：如果左邊的像素比右邊的更亮，則記錄為1，否則為0.
通過hash值來計算漢明距離

def dhash(image):
# 將圖片轉化為8*8
image = cv2.resize(image, (9, 8), interpolation=cv2.INTER_CUBIC)
# 將圖片轉化為灰度圖
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
dhash_str = ''
for i in range(8):
for j in range(8):
if gray[i, j] > gray[i, j + 1]:
dhash_str = dhash_str + '1'
else:
dhash_str = dhash_str + '0'
result = ''
for i in range(0, 64, 4):
result += ''.join('%x' % int(dhash_str[i: i + 4], 2))
# print("dhash值",result)
return result

def campHash(hash1, hash2):
n = 0
# hash長度不同返回-1,此時不能比較
if len(hash1) != len(hash2):
return -1
# 如果hash長度相同遍歷長度
for i in range(len(hash1)):
if hash1[i] != hash2[i]:
n = n + 1
return n