IH/iihmsp13/exp/script_spatial.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 from numpy import *
  14 from math import acos,asin,atan,sqrt,pi,isnan
  15 from outilsBase import conversion, getBit, setBit,matrice_lscs,matrice_to_bits, LSCs,embarque2,ci2_watermark,ITFACTOR,f
  16 from random import *
  17 from copy import deepcopy
  18 import Image as im
  19 from ImageChops import difference
  20 from evaluation import Evaluation
  21 from suite import *
  22 from attaque import Attaque
  23 from Levenshtein import distance
  24
  25
  26
  27 def sauve_img_msg(mat,k):
  28     lp = [0 if x == 0.0 else 255 for x in mat]
  29     at = im.new("L",(64,64))
  30     at.putdata(lp)
  31     at.save("msg_"+str(k)+".png")
  32
  33
  34
  35
  36
  37
  38
  39 def PSNR(mat1,mat2):
  40     (li,co) = mat1.shape
  41     '''
  42     Retourne le PSNR entre deux images.
  43     '''
  44     from math import log
  45     densite = 2**8-1
  46     eqm = 0
  47     for k in xrange(li):
  48         for l in xrange(co):
  49             eqm+=(mat1[k][l] - mat2[k][l])**2
  50     r= float(eqm)/li/co
  51     if r !=0:
  52         return 10*log(densite**2/r,10)
  53     else:
  54         return "Infini"
  55
  56
  57
  58 def diff(mat1,mat2):
  59     lm=len(mat1)
  60     cpt = 0
  61     for k in xrange(lm):
  62         if mat1[k] != mat2[k] :
  63             cpt +=1
  64             #print mat1[k],mat2[k]
  65     return float(100)*cpt/lm
  66
  67 def arrondi_en_entier(mat):
  68     (l,c) = mat.shape
  69     return array([[round(mat[i][j]) for j in xrange(c)]for i in xrange(l)])
  70
  71
  72
  73 def  occurrences(s, lst):
  74     return [i for i,e in enumerate(lst) if e == s]
  75
  76
  77 def coefs_rifqi(ch1,ch2):
  78     a,b,c,d = 0,0,0,0
  79     assert len(ch1) == len(ch2)
  80     for i,e in enumerate(ch1):
  81         if e == 1 :
  82             if ch2[i] == 1 :
  83                 a+=1
  84             else :
  85                 b +=1
  86         else :
  87             if ch2[i] == 1 :
  88                 c+=1
  89             else :
  90                 d +=1
  91     """
  92     r = sqrt(a**2 + b**2 +c**2)
  93     l = acos(float(c)/r)
  94     m = asin(float(b)/(r*sin(l)))
  95     """
  96     return (a,b,c,d)
  97
  98 def distance_rifqi(ch1,ch2,gamma):
  99     phi0=pi/4
 100     def FD(phi,gamma,phi0):
 101         return float(1)/(1 + exp(float(phi-phi0)/gamma))
 102     (a,b,c,_) = coefs_rifqi(ch1,ch2)
 103     phi = atan(float(b+c)/(a+0.00001))
 104     r = float(FD(phi,gamma,phi0)-FD(pi/2,gamma,phi0))/(FD(0,gamma,phi0)-FD(pi/2,gamma,phi0))
 105     return 1-r
 106
 107
 108
 109 def extrait_message(S_p,S_c,S_m,x,lm):
 110
 111     lh=len(x)
 112     nbit = int(ITFACTOR * lh)
 113     #recup derniere date de modif
 114     date_m=[0]*lh
 115     for k in xrange(nbit):
 116         date_m[S_p[k]]=k
 117
 118     mini = min(date_m)
 119     #suppression des iteration inutile: 0-> pair, 1-> impair
 120     marque = [0 for _ in xrange(lm)]
 121     S=[(-1,0)]*lh
 122     for k in xrange(mini):
 123         marque[S_m[k]] = f(S_m[k],marque)
 124     for k in xrange(mini,nbit):
 125         S[S_p[k]]= (S_c[k],marque[S_c[k]])
 126         marque[S_m[k]] = f(S_m[k],marque)
 127
 128     m=[[] for _ in xrange(lm)]
 129
 130     for k in xrange(lh):
 131         (v,p) = S[k]
 132         if v != -1 :
 133             m[v] += [(x[k]+p)%2]
 134
 135     mp=[]
 136     for l in m:
 137         k = average(l)
 138         if isnan(k) or isnan(round(k)):
 139             print "k",k
 140             print "S_p,",S_p
 141             print "S_c,",S_c
 142             print "S_m,",S_m
 143             print "x,",x
 144             print "lm,",lm
 145             print "nbit,",nbit
 146             print "l,",l
 147         else:
 148             mp+=[int(round(k))]
 149     return mp
 150
 151
 152
 153 def experience(nom_fichier,marque):
 154     str_acc = "nom;"+nom_fichier
 155     lm = len(marque)
 156     initiale_image = im.open(nom_fichier+".png")
 157     (taillex,tailley) = initiale_image.size
 158     initiale_matrice =  array(initiale_image.getdata()).reshape((taillex,tailley))
 159
 160     (marquee_matrice,S_p,S_c,S_m) = ci2_watermark(initiale_matrice,marque)
 161     #sauvegarde de l'image
 162     (l,h)=marquee_matrice.shape
 163
 164
 165
 166     # Calcul du nombre de différences dans la matrice
 167     #str_acc += ";#lscs;" + str(diff(initiale_lscs_a_iterer,initiale_lscs))
 168     # psnr
 169     str_acc += ";PSNR;" + str(PSNR(initiale_matrice,marquee_matrice))
 170
 171
 172     nbexp=40
 173     attaquee_matrice = []
 174
 175     """
 176     # matrices attaquees par rotation
 177     #print "rotations"
 178     for k in xrange(nbexp):
 179         at  = Attaque.rotation(marquee_matrice,
 180                                4.5*(k+1),
 181                                1)
 182         attaquee_matrice += [at]
 183
 184     # matrices attaquees compression jpeg
 185     #print "compression"
 186     for k in xrange(nbexp):
 187         at  = Attaque.jpeg(marquee_matrice,
 188                            nom_fichier,
 189                            100-2*(k+1))
 190         attaquee_matrice +=  [at]
 191         print k
 192
 193
 194     # matrices attaquees compression jp2000
 195     #print "compression jp2000"
 196     for k in xrange(nbexp):
 197         at  = Attaque.jp2(marquee_matrice,
 198                            nom_fichier,
 199                            100-5*(k+1))
 200         attaquee_matrice +=  [at]
 201
 202
 203
 204     #print "decoupage"
 205     # matrices attaquees decoupage
 206     for k in xrange(nbexp):
 207         t = int(0.05*(k+1)*min(taillex,tailley))
 208         at  = Attaque.decoupage(marquee_matrice,
 209                                 t,
 210                                 (0,0))
 211         attaquee_matrice +=  [at]
 212
 213     #print "flou"
 214     # matrices attaquees flou
 215     for k in xrange(nbexp):
 216         t=0.04*(k+1)
 217         at  = Attaque.flou(marquee_matrice,t)
 218         attaquee_matrice +=  [at]
 219
 220
 221     #print "contraste"
 222     # matrices attaquees contrast
 223     for k in xrange(nbexp):
 224         t=0.0+0.04*(k+1)
 225         at  = Attaque.contraste(marquee_matrice,t)
 226         attaquee_matrice +=  [at]
 227
 228
 229     # matrices attaquees redimensionnement
 230     #print "dimensionnement"
 231     for k in xrange(nbexp):
 232         t=0.5+0.05*(k+1)
 233         attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
 234                                                        t,
 235                                                        1)]
 236
 237
 238
 239     #print "attaque LSB"
 240     # matrices attaquees contrast
 241     for k in xrange(nbexp):
 242         t=1-float(k)/(nbexp)
 243         at  = Attaque.changeLSC(marquee_matrice,t)
 244         attaquee_matrice +=  [at]
 245
 246     """
 247     # matrices attaquees en appliquant à nouveau l'algo
 248     #print "ci2 again"
 249     for k in xrange(nbexp):
 250         it2 = ITFACTOR*30*(k+1)/nbexp
 251         mp=  [randint(0,1) for _ in xrange(lm)]
 252         attaquee_matrice += [Attaque.ci2_watermark_again(marquee_matrice,
 253                                                        mp,it2)]
 254
 255     #print  "nombre d'attaques",len(attaquee_matrice)
 256
 257     # evaluation des attaques
 258     c=0
 259     for am in attaquee_matrice:
 260         c +=1
 261         #print "mat",c
 262         attaquee_lscs = matrice_lscs(matrice_to_bits(am))
 263         msg = extrait_message(S_p,S_c,S_m,attaquee_lscs,lm)
 264         #d = diff(msg,msg_init)
 265         #print "diff",d
 266
 267         #d= round(float(distance("".join([str(x) for x in msg]),"".join([str(x) for x in msg_init])))/len(msg),2)
 268         d = round(distance_rifqi(msg,marque,0.1),2)
 269         sauve_img_msg(msg,c)
 270         str_acc += ";" + str(d)
 271         #print "img ", c
 272
 273     return str_acc
 274
 275
 276
 277
 278
 279
 280 file_msg  = "invader.png"
 281 message = [x if x==0 else 1 for x in im.open(file_msg).getdata()]
 282 print "taille du message  =", len(message)
 283 k=0
 284
 285
 286 for j in sample(xrange(1,3001),2):
 287     print experience("../../../../BCG10/Oxford11/experiments/images/"+str(j),message)
 288     print k
 289     k+=1
 290
 291 """
 292
 293 print experience("../../../../BCG10/Oxford11/experiments/images/2838", message)
 294
 295 print experience("../../../../BCG10/Oxford11/experiments/images/350",message)
 296 #lscs;49.1746808016;PSNR;51.2134378146;0.62;0.65;0.63;0.97;0.98;0.97;0.97;0.98;0.98;0.99;0.98;0.99;0.99;0.99;0.99;0.99;0.99;0.99;0.99;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0;0.0
 297 print experience("../../../../BCG10/Oxford11/experiments/images/2812",message)
 298 #lscs;49.1865064984;PSNR;51.2123935338;0.01;0.01;0.01;0.01;0.03;0.01;0.01;0.02;0.01;0.23;0.02;0.03;0.04;0.05;0.14;0.11;0.15;0.2;0.22;0.0;0.0;0.0;0.0;0.0;0.0;
 299 """