stc/exp/raphus/attaques.py

   1 #-*-coding:utf-8-*-
   2
   3 #############################################
   4 # Script réalisé dans le cadre du papier
   5 # concernant l'utilisation de plusieurs
   6 # fonctions chaotiques (pas seulement la
   7 # négation vectorielle) pour le tatouage.
   8 #
   9 # On utilise 3 fonctions différentes, on tatoue
  10 # dans le domaine ondelette.
  11 #############################################
  12 import pywt
  13
  14 from numpy import *
  15
  16 #from outilsBase import conversion, getBit, setBit
  17 from random import *
  18 from copy import deepcopy
  19 import Image as im
  20 from ImageChops import difference
  21 from suite import *
  22 from attaque import Attaque
  23
  24 def matrice_to_bits(matrice):
  25     '''
  26     Renvoie la matrice des écritures binaires de matrice.
  27     Les coefficients floants deviennent des chaînes (str) de bits.
  28     '''
  29     (m,n) = matrice.shape
  30     retour = []
  31     for l in range(m):
  32         ligne = []
  33         for c in range(n):
  34             ligne.append(conversion(str(matrice[l,c]),2))
  35         retour.append(ligne)
  36     return retour
  37
  38
  39
  40 def matrice_lscs(matrice,lscs):
  41     '''
  42     Matrice est une liste de listes, lscs est une liste.
  43
  44     A partir d'une matrice de coefficients binaires, vus comme
  45     des chaines de caractères, extrait les bits dont les positions
  46     sont données par la liste lscs.
  47
  48     Dans la liste lscs, un entier positif signifie devant la virgule,
  49     un entier négatif signifie derrière. Le premier bit devant la
  50     virgule est le bit 1, le premier bit derrière la virgule est le -1.
  51
  52     Le retour est une liste de bits (entiers).
  53     '''
  54     m,n = len(matrice), len(matrice[0])
  55     retour = []
  56     for l in range(m):
  57         for c in range(n):
  58             #num = str(round(float(matrice[l][c]),2))
  59             num = matrice[l][c]
  60
  61             if '.' not in num:
  62                 ent,dec = num.replace('-',''),'0'
  63             else:
  64                 ent,dec = num.replace('-','').split('.')
  65             ent,dec = list(ent),list(dec)
  66             ent.reverse()
  67             for lsc in lscs:
  68                 if lsc > 0 and len(ent)>=lsc:
  69                     retour.append(ent[lsc-1])
  70                 elif lsc<0 and len(dec)>=abs(lsc):
  71                     retour.append(dec[abs(lsc)-1])
  72                 else:
  73                     retour.append('0')
  74     return [int(k) for k in retour][:-3]
  75
  76
  77 def embarque(liste,matrice,lscs):
  78     m,n = len(matrice), len(matrice[0])
  79     retour = []
  80     cpt = 0
  81     for l in range(m):
  82         for c in range(n):
  83             if '-' in matrice[l][c]:
  84                 signe = '-'
  85             else:
  86                 signe = ''
  87             if '.' not in matrice[l][c]:
  88                 ent,dec = matrice[l][c].replace('-',''),'0'
  89             else:
  90                 ent,dec = matrice[l][c].replace('-','').split('.')
  91             ent,dec = list(ent),list(dec)
  92             ent.reverse()
  93             maximum = max([abs(k) for k in lscs])
  94             ent = list(''.join(ent).zfill(maximum+2))
  95             dec = list(''.join(dec).zfill(maximum+2))
  96             print dec
  97             for lsc in lscs:
  98                 if lsc > 0:
  99                     ent[lsc-1] = str(liste[cpt])
 100                 else:
 101                     dec[abs(lsc)-1] = str(liste[cpt])
 102                 cpt += 1
 103             ent.reverse()
 104             ent = ''.join(ent)
 105             dec = ''.join(dec)
 106             print ent+'.'+dec
 107
 108
 109
 110 def f(L):
 111     assert len(L)%4 == 1
 112     n = len(L)/4
 113     retour = [int(not L[k]) for k in range(n)]
 114     retour.extend([L[k-n] for k in range(n,2*n)])
 115     retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in range(2*n,4*n)])
 116     retour.extend([int(not L[2*n])])
 117     return retour
 118
 119
 120
 121
 122 def f(L):
 123     retour = [int(not L[0])]
 124     retour.extend([L[k-1] for k in range(1,len(L))])
 125     return retour
 126
 127
 128
 129
 130 def f(x):
 131     rl=[]
 132     k = 1
 133     for el in x:
 134         if k%2 != 0 :
 135             rl.append(int(not el))
 136         else:
 137             rl.append(0 if sum(x[k-2:k])%2==0 else 1 )
 138         k+=1
 139     return rl
 140
 141
 142
 143
 144 def f(i,x):
 145     r = 0
 146     if i%2 == 0 :
 147         r = int(not x[i])
 148     else:
 149         r = 0 if sum(x[i-1:i+1])%2==0 else 1
 150     return r
 151
 152
 153
 154 def f(i,L):
 155     return int(not L[i])
 156
 157
 158
 159 def embarque2(liste,matrice,lscs):
 160
 161     m,n = len(matrice), len(matrice[0])
 162     retour = deepcopy(matrice)
 163     cpt = 0
 164     for l in range(m):
 165         for c in range(n):
 166             for lsc in lscs:
 167                 try:
 168                     retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt])
 169                     cpt += 1
 170                 except:
 171                     pass
 172     return retour
 173
 174 def PSNR(mat1,mat2):
 175     (li,co) = mat1.shape
 176     '''
 177     Retourne le PSNR entre deux images.
 178     '''
 179     from math import log
 180     densite = 2**8-1
 181     eqm = 0
 182     for k in range(li):
 183         for l in range(co):
 184             eqm+=(mat1[k][l] - mat2[k][l])**2
 185     r= float(eqm)/li/co
 186     if r !=0:
 187         return 10*log(densite**2/r,10)
 188     else:
 189         return "Infini"
 190
 191
 192
 193 def diff(mat1,mat2):
 194     lm=len(mat1)
 195     cpt = 0
 196     for k in range(lm):
 197         if mat1[k] != mat2[k] :
 198             cpt +=1
 199             #print mat1[k],mat2[k]
 200     return float(100)*cpt/lm
 201
 202 def arrondi_en_entier(mat):
 203     (l,c) = mat.shape
 204     return array([[round(mat[i][j]) for j in range(c)]for i in range(l)])
 205
 206
 207
 208
 209
 210 def experience(nom_fichier):
 211     str_acc = "nom;"+nom_fichier
 212
 213     initiale_image = im.open(nom_fichier+".png")
 214     (taillex,tailley) = initiale_image.size
 215     initiale_matrice =  array(initiale_image.getdata()).reshape((taillex,tailley))
 216
 217     #recup
 218     hote_dct = Dct(nom_fichier+".png",idx_dct)
 219     hote_dct2 = Dct(nom_fichier+".png",idx_dct)
 220
 221     initiale_dct= deepcopy(hote_dct.get_ext_dct())
 222
 223
 224     # recup bits insignifiants
 225     initiale_lscs = matrice_lscs(matrice_to_bits(initiale_dct),LSCs)
 226     initiale_lscs_a_iterer = deepcopy(initiale_lscs)
 227
 228     # Nb LSCs
 229     lm = len(initiale_lscs)
 230     # Itérations D2
 231     ciis = CIIS(random(),random(),random()/2,lm-1,lm)._genere()
 232     for k in range(4*lm):
 233         strat = ciis.next()
 234         #print strat
 235         initiale_lscs_a_iterer[strat] = int(
 236             f(strat,initiale_lscs_a_iterer))
 237
 238
 239
 240     # Calcul du nombre de différences dans la matrice DCT
 241
 242
 243     str_acc += ";#lscs;" + str(lm)
 244
 245
 246     dif_iter = diff(initiale_lscs,initiale_lscs_a_iterer)
 247     str_acc += ";#diff it ; " + str(dif_iter)
 248
 249
 250     # Tatouage de la matrice")
 251     marquee_ext_dct = embarque2(initiale_lscs_a_iterer,
 252                            initiale_dct,LSCs)
 253
 254     # reconstruction de la matrice complete
 255     hote_dct2.set_ext_dct(marquee_ext_dct)
 256     marquee_matrice = hote_dct2._matrice
 257     marquee_matrice = arrondi_en_entier(marquee_matrice)
 258
 259
 260     #sauvegarde de l'image
 261     (l,h)=marquee_matrice.shape
 262     at = im.new("L",(l,h))
 263     at.putdata(marquee_matrice.flatten())
 264     at.save(nom_fichier+"_bis.png")
 265     at.show()
 266
 267
 268 #listing = os.listdir(path_cover)
 269
 270
 271
 272     # psnr
 273     str_acc += ";PSNR;" + str(PSNR(initiale_matrice,marquee_matrice))
 274
 275
 276     nbexp=10
 277     # matrices attaquees par rotation
 278     attaquee_matrice = []
 279     print "rotations"
 280     for k in range(nbexp):
 281         at  = Attaque.rotation(marquee_matrice,
 282                                3*(k+1),
 283                                1)
 284         attaquee_matrice += [at]
 285
 286     # matrices attaquees compression jpeg
 287     print "compression"
 288     for k in range(nbexp):
 289         at  = Attaque.jpeg(marquee_matrice,
 290                            nom_fichier,
 291                            100-3*(k+1))
 292         attaquee_matrice +=  [at]
 293
 294
 295     # matrices attaquees compression jp2000
 296     print "compression jp2000"
 297     for k in range(nbexp):
 298         at  = Attaque.jp2(marquee_matrice,
 299                            nom_fichier,
 300                            100-10*(k+1))
 301         attaquee_matrice +=  [at]
 302
 303
 304
 305     print "decoupage"
 306     # matrices attaquees decoupage
 307     for k in range(nbexp):
 308         t = int(0.1*(k+1)*min(taillex,tailley))
 309         at  = Attaque.decoupage(marquee_matrice,
 310                                 t,
 311                                 (0,0))
 312         attaquee_matrice +=  [at]
 313
 314     print "flou"
 315     # matrices attaquees flou
 316     for k in range(nbexp):
 317         t=0.6+0.08*(k+1)
 318         at  = Attaque.flou(marquee_matrice,t)
 319         attaquee_matrice +=  [at]
 320
 321     print "contraste"
 322     # matrices attaquees contrast
 323     for k in range(nbexp):
 324         t=0.6+0.08*(k+1)
 325         at  = Attaque.contraste(marquee_matrice,t)
 326         attaquee_matrice +=  [at]
 327
 328
 329     # matrices attaquees redimensionnement
 330     print "dimensionnement"
 331     attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
 332                                                    0.75,
 333                                                    1)]
 334     attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
 335                                                    1.5,
 336                                                    1)]
 337
 338
 339
 340
 341     print  "nombre d'attaques",len(attaquee_matrice)
 342
 343     # evaluation des attaques
 344     _,(marquee_H2,marquee_V2,marquee),(_,_,_)  = \
 345         pywt.wavedec2(marquee_matrice,
 346                       'db1',
 347                       level = 2)
 348     marquee_lscs = matrice_lscs(matrice_to_bits(marquee_matrice),LSCs)
 349
 350     c=0
 351     for am in attaquee_matrice:
 352         c +=1
 353         attaquee = am
 354
 355         attaquee_lscs = matrice_lscs(matrice_to_bits(attaquee),LSCs)
 356         d = diff(marquee_lscs,attaquee_lscs)
 357         str_acc += ";" + str(d)
 358
 359
 360
 361     return str_acc
 362
 363
 364 """
 365 for j in sample(range(1,3001),2):
 366     print experience("../images/"+str(j),3)
 367
 368 """
 369 print experience("../images/"+str(3622),3)