图像哈希：全局＋局部提取特征

文章信息

1. 作者：梁小平，唐振军
2. 期刊：ACM Trans. Multimedia Comput. Commun. Appl（三区）
3. 题目：Robust Hashing via Global and Local Invariant Features for Image Copy Detection

目的、实验步骤及结论

1. 目的：通过全局和局部提取特征来生成最终图像的哈希值。

2. 实验步骤：
   

   • 数据预处理：双线性插值（512 * 512）
   • 全局特征：
     • PDFT生成显著图S
     • 对GLCM使用四种参数（不同的角度）得到四个矩阵，每个矩阵得到4个统计特征，得到 1 * 16 的全局特征向量
   • 局部特征：
     • 使用HSV中的V分量，分块（64 * 64），将每一个块拼接成一个列向量，使用KPCA后得到d * N的矩阵。
     • 计算每一个矩阵维度的均值作为参考向量，计算所有向量（每一列）和参考向量的距离作为局部特征
   • 生成哈希值：将全局特征和局部特征进行拼接，使用量度排序作为最后的哈希值（长度为N+16）。
   • 相似性评价：使用汉明距离判断两张图片是否一致，若小于阈值则是相同图片。

3. 结论

   • 首次提出KPCA应用于图像哈希
   • 适用于混合攻击
   • 全局特征对几何攻击（尤其是缩放和旋转）很敏感，而局部特征无法保持全局上下文信息导致判别效果不佳。
   • 使用全局和局部结合特征可以更加有利于互补进行提取特征。

本篇论文的实现代码如下：

def image_hash(img_path):
    img = processing(img_path)
    global_feature = global_feature_gen(img)
    local_feature = local_feature_gen(img, 10000, 4)
    h_i = gen_hashing(global_feature, local_feature)
    return h_i

def processing(img_path):
    """
    input：图片的路径
    output：处理后的RGB图片
    """
    try:
        img = cv2.imread(img_path)
        x = img.shape[0]//2 # 高度
        y = img.shape[1]//2 # 宽度
        Min = x if x<y else y
        cropped_image = img[x-Min:x+Min, y-Min:y+Min] # 裁剪图像
        img = cv2.resize((cropped_image), (512,512), interpolation=cv2.INTER_LINEAR)
    except:
        img = imageio.mimread(img_path)
        img = np.array(img)
        img = img[0]
        img = img[:, :, 0:3]
        x = img.shape[0]//2 # 高度
        y = img.shape[1]//2 # 宽度
        Min = x if x<y else y
        cropped_image = img[x-Min:x+Min, y-Min:y+Min, :] # 裁剪图像
        img = cv2.resize((cropped_image), (512,512), interpolation=cv2.INTER_LINEAR)
#     out = cv2.GaussianBlur(img, (3, 3),1.3) # 使用python自带的高斯滤波
    kernel = np.array([[1,2,1],[2,4,2],[1,2,1]])/16
    out = cv2.filter2D(img, -1 , kernel=kernel)  # 二维滤波器
    # out = cv2.cvtColor(out, cv2.COLOR_BGR2RGB)
    out = cv2.cvtColor(out, cv2.COLOR_BGR2HSV)
    return out

def local_feature_gen(img, sigma, n_components):
    """
    iamge:(512,512,3)
    return: 降维之后的图像(d, N)
    """
    from sklearn.decomposition import PCA, KernelPCA
    N_list = []
    V = img[:,:,2]
    for i in range(0,V.shape[0],64):
        for j in range(0,V.shape[1],64):
            image_block = V[i:i+64, j:j+64]
            N_list.append(image_block.reshape(-1)[:])
    N_list = np.array(N_list).copy()
    # kernel_pca = KernelPCA(n_components=4, kernel="poly", gamma=10)
    # result = kernel_pca.fit_transform(N_list)
    result = kpca(N_list, sigma, 4).copy()
    return result.T
    
def gaussian_kernel(X, sigma):
    sq_dists = pdist(X, 'sqeuclidean')  # 计算所有样本点之间的平方欧式距离
    mat_sq_dists = squareform(sq_dists)  # 转换成矩阵形式
    return np.exp(-mat_sq_dists / (2 * sigma**2))  # 计算高斯核矩阵

def kpca(X, sigma, n_components):
    # 步骤1: 计算高斯核矩阵
    K = gaussian_kernel(X, sigma)
    # 步骤2: 中心化核矩阵
    N = K.shape[0]
    one_n = np.ones((N, N)) / N
    K = K - one_n.dot(K) - K.dot(one_n) + one_n.dot(K).dot(one_n)
    # 步骤3: 计算特征值和特征向量
    eigenvalues, eigenvectors = eigh(K)
    eigenvalues, eigenvectors = eigenvalues[::-1], eigenvectors[:, ::-1]  # 降序排列
    # 步骤4: 提取前n个特征向量
    alphas = eigenvectors[:, :n_components]
    lambdas = eigenvalues[:n_components]
    return alphas / np.sqrt(lambdas)  # 归一化特征向量

def global_feature_gen(img):
    P = pqft(img)
    return P
def pqft(img, sigma=8):
    h, w, channel = img.shape
    r, b, g = img[:,:,0], img[:,:,1], img[:,:,2]
    R = r - (g + b)/2
    G = g - (r + b)/2
    B = b - (r + g)/2
    Y = (r + g)/2 - (abs(r - g))/2 - b
    RG = R - G
    BY =B - Y
    I1 = ((r+g+b) /3)
    M = np.zeros((h, w))
    f1 = M + RG * 1j
    f2 = BY + I1 * 1j
    F1 = np.fft.fft2(f1)
    F2 = np.fft.fft2(f2)
    phaseQ1 = np.angle(F1)
    phaseQ2 = np.angle(F2)
    ifftq1 = np.fft.ifft2(np.exp(phaseQ1 * 1j))
    ifftq2 = np.fft.ifft2(np.exp(phaseQ2 * 1j))
    absq1 = np.abs(ifftq1)
    absq2 = np.abs(ifftq2)
    squareq=(absq1+absq2) * (absq1+absq2)
    out = cv2.GaussianBlur(squareq, (5, 5), sigma)
    out = cv2.normalize(out.astype('float'), None, 0, 255, cv2.NORM_MINMAX)
    return out

def gen_hashing(global_feature, local_feature):
    """
    先求出列均值，在算出每一列之间的距离，最后使用序数度量来代表哈希值
    input:array (x,64,64)
    output:list (x)
    """
    result = glcm(global_feature)
    y_mean = np.mean(local_feature, axis = 0)
    z = np.sqrt((y_mean[1:] - y_mean[:-1]) ** 2) * 1000
    result.extend(z)
    sorted_indices = sorted(range(len(result)), key=lambda i: result[i])
    result = [sorted_indices.index(i)+1 for i in range(len(result))]
    return result
    
def glcm(img, levels = 32):
    '''
    https://www.cnblogs.com/xiaoliang-333/articles/16937977.html
    graycom = greycomatrix(img, [1], [0, np.pi/4, np.pi/2, np.pi*3/4], levels=256)
    c = feature.greycoprops(graycom, 'contrast')  # 对比度
    d = feature.greycoprops(graycom, 'dissimilarity')   # 相异性
    h = feature.greycoprops(graycom, 'homogeneity')    # 同质性
    e = feature.greycoprops(graycom, 'energy')    # 能量
    corr = feature.greycoprops(graycom, 'correlation')    # 相关性
    ASM = feature.greycoprops(graycom, 'ASM')     # 角二阶矩
    '''
    from skimage.feature import graycomatrix, graycoprops
    img = img.astype(np.float64)
    img = img * levels / 256.0
    img = img.astype(np.uint8)
    distances = [1, 1, 1, 1]  
    angles = [0, 45, 90, 135] 
    #初始化一个空列表来存储GLCM矩阵统计特征
    glcms = []
    #为每个距离和角度组合计算 GLCM
    for d,a in zip(distances,angles):
        glcm = graycomatrix(img,distances=[d],angles=[a],levels=levels,symmetric=True, normed=True)
        contrast = graycoprops(glcm, 'ASM')     
        glcms.append(contrast[0, 0])
        
        correlation = graycoprops(glcm, 'contrast')  
        glcms.append(correlation[0, 0])
        
        energy = graycoprops(glcm, 'correlation')    
        glcms.append(energy[0, 0])
        
        homogeneity = graycoprops(glcm, 'homogeneity')    
        glcms.append(homogeneity[0, 0])
    # return np.array(np.round(glcms), dtype=np.uint8)
    return glcms

def dist_img(h1,h2):
    # distance = np.count_nonzero(np.array(list(h1)) != np.array(list(h2)))
    # return distance / len(h1)
    h1 = np.array(h1)
    h2 = np.array(h2)
    return sum(np.abs(h1-h2))/len(h1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159