IH/iihmsp13/exp/script_spatial_roc.py

   1 #-*-coding:utf-8-*-
   2 import pywt
   3 from numpy import *
   4 from math import acos,asin,atan,sqrt,pi,isnan
   5
   6 from outilsBase import conversion, getBit, setBit
   7 from random import *
   8 from copy import deepcopy
   9 import Image as im
  10 from ImageChops import difference
  11 from evaluation import Evaluation
  12 from suite import *
  13 from attaque import Attaque
  14
  15 LSCs= [1]
  16
  17
  18
  19 def matrice_to_bits(matrice):
  20     '''
  21     Renvoie la matrice des écritures binaires de matrice.
  22     Les coefficients floants deviennent des chaînes (str) de bits.
  23     '''
  24     (m,n) = matrice.shape
  25     retour = []
  26     for l in range(m):
  27         ligne = []
  28         for c in range(n):
  29             ligne.append(conversion(str(matrice[l,c]),2))
  30         retour.append(ligne)
  31     return retour
  32
  33
  34 def matrice_lscs(matrice,lscs):
  35     '''
  36     Matrice est une liste de listes, lscs est une liste.
  37
  38     A partir d'une matrice de coefficients binaires, vus comme
  39     des chaines de caractères, extrait les bits dont les positions
  40     sont données par la liste lscs.
  41
  42     Dans la liste lscs, un entier positif signifie devant la virgule,
  43     un entier négatif signifie derrière. Le premier bit devant la
  44     virgule est le bit 1, le premier bit derrière la virgule est le -1.
  45
  46     Le retour est une liste de bits (entiers).
  47     '''
  48     m,n = len(matrice), len(matrice[0])
  49     retour = []
  50     for l in range(m):
  51         for c in range(n):
  52             #num = str(round(float(matrice[l][c]),2))
  53             num = matrice[l][c]
  54
  55             if '.' not in num:
  56                 ent,dec = num.replace('-',''),'0'
  57             else:
  58                 ent,dec = num.replace('-','').split('.')
  59             ent,dec = list(ent),list(dec)
  60             ent.reverse()
  61             for lsc in lscs:
  62                 if lsc > 0 and len(ent)>=lsc:
  63                     retour.append(ent[lsc-1])
  64                 elif lsc<0 and len(dec)>=abs(lsc):
  65                     retour.append(dec[abs(lsc)-1])
  66                 else:
  67                     retour.append('0')
  68     return [int(k) for k in retour][:-3]
  69
  70
  71 def embarque(liste,matrice,lscs):
  72     m,n = len(matrice), len(matrice[0])
  73     retour = []
  74     cpt = 0
  75     for l in range(m):
  76         for c in range(n):
  77             if '-' in matrice[l][c]:
  78                 signe = '-'
  79             else:
  80                 signe = ''
  81             if '.' not in matrice[l][c]:
  82                 ent,dec = matrice[l][c].replace('-',''),'0'
  83             else:
  84                 ent,dec = matrice[l][c].replace('-','').split('.')
  85             ent,dec = list(ent),list(dec)
  86             ent.reverse()
  87             maximum = max([abs(k) for k in lscs])
  88             ent = list(''.join(ent).zfill(maximum+2))
  89             dec = list(''.join(dec).zfill(maximum+2))
  90             print dec
  91             for lsc in lscs:
  92                 if lsc > 0:
  93                     ent[lsc-1] = str(liste[cpt])
  94                 else:
  95                     dec[abs(lsc)-1] = str(liste[cpt])
  96                 cpt += 1
  97             ent.reverse()
  98             ent = ''.join(ent)
  99             dec = ''.join(dec)
 100             print ent+'.'+dec
 101
 102
 103
 104 def f(L):
 105     assert len(L)%4 == 1
 106     n = len(L)/4
 107     retour = [int(not L[k]) for k in range(n)]
 108     retour.extend([L[k-n] for k in range(n,2*n)])
 109     retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in range(2*n,4*n)])
 110     retour.extend([int(not L[2*n])])
 111     return retour
 112
 113
 114
 115
 116 def f(L):
 117     retour = [int(not L[0])]
 118     retour.extend([L[k-1] for k in range(1,len(L))])
 119     return retour
 120
 121
 122
 123 def f(x):
 124     rl=[]
 125     k = 1
 126     for el in x:
 127         if k%2 != 0 :
 128             rl.append(int(not el))
 129         else:
 130             rl.append(0 if sum(x[k-2:k])%2==0 else 1 )
 131         k+=1
 132     return rl
 133
 134 def f(i,x):
 135     r = 0
 136     if i%2 == 0 :
 137         r = int(not x[i])
 138     else:
 139         r = 0 if sum(x[i-1:i+1])%2==0 else 1
 140     return r
 141
 142 def f(i,L):
 143     return int(not L[i])
 144 def coefs_rifqi(ch1,ch2):
 145     a,b,c,d = 0,0,0,0
 146     assert len(ch1) == len(ch2)
 147     for i,e in enumerate(ch1):
 148         if e == 1 :
 149             if ch2[i] == 1 :
 150                 a+=1
 151             else :
 152                 b +=1
 153         else :
 154             if ch2[i] == 1 :
 155                 c+=1
 156             else :
 157                 d +=1
 158     """
 159     r = sqrt(a**2 + b**2 +c**2)
 160     l = acos(float(c)/r)
 161     m = asin(float(b)/(r*sin(l)))
 162     """
 163     return (a,b,c,d)
 164
 165 def distance_rifqi(ch1,ch2,gamma):
 166     phi0=pi/4
 167     def FD(phi,gamma,phi0):
 168         return float(1)/(1 + exp(float(phi-phi0)/gamma))
 169     (a,b,c,_) = coefs_rifqi(ch1,ch2)
 170     phi = atan(float(b+c)/(a+0.00001))
 171     r = float(FD(phi,gamma,phi0)-FD(pi/2,gamma,phi0))/(FD(0,gamma,phi0)-FD(pi/2,gamma,phi0))
 172     return 1-r
 173
 174
 175
 176
 177 def embarque2(liste,matrice,lscs):
 178     m,n = len(matrice), len(matrice[0])
 179     #print m,n,liste,matrice,lscs
 180     retour = deepcopy(matrice)
 181     cpt = 0
 182     for l in range(m):
 183         for c in range(n):
 184             for lsc in lscs:
 185                 try:
 186                     retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt])
 187                     cpt += 1
 188                 except:
 189                     pass
 190     return retour
 191
 192 def PSNR(mat1,mat2):
 193     (li,co) = mat1.shape
 194     '''
 195     Retourne le PSNR entre deux images.
 196     '''
 197     from math import log
 198     densite = 2**8-1
 199     eqm = 0
 200     for k in range(li):
 201         for l in range(co):
 202             eqm+=(mat1[k][l] - mat2[k][l])**2
 203     r= float(eqm)/li/co
 204     if r !=0:
 205         return 10*log(densite**2/r,10)
 206     else:
 207         return "Infini"
 208
 209
 210
 211 def diff(mat1,mat2):
 212     lm=len(mat1)
 213     cpt = 0
 214     for k in range(lm):
 215         if mat1[k] != mat2[k] :
 216             cpt +=1
 217             #print mat1[k],mat2[k]
 218     return float(100*cpt)/lm
 219
 220 def arrondi_en_entier(mat):
 221     (l,c) = mat.shape
 222     return array([[round(mat[i][j]) for j in range(c)]for i in range(l)])
 223
 224
 225 def get_initiale_image(nom_fichier):
 226     initiale_image = im.open(nom_fichier+".png")
 227     (taillex,tailley) = initiale_image.size
 228     initiale_matrice =  array(initiale_image.getdata()).reshape((taillex,tailley))
 229     return initiale_matrice
 230
 231
 232 def get_marque_matrice(nom_fichier,marque):
 233         #recuperer la marque comme un vecteur de 0,1 et pas de nombres binaires
 234     lm = len(marque)
 235     str_acc = "nom;"+nom_fichier
 236     LSCs= [1]
 237     msg_init = [x for x in marque]
 238
 239     initiale_image = im.open(nom_fichier+".png")
 240     (taillex,tailley) = initiale_image.size
 241     initiale_matrice =  array(initiale_image.getdata()).reshape((taillex,tailley))
 242
 243     initiale_lscs = matrice_lscs(matrice_to_bits(initiale_matrice),LSCs)
 244     initiale_lscs_a_iterer = deepcopy(initiale_lscs)
 245
 246     # Nb LSCs
 247     lh = len(initiale_lscs)
 248     nbit = 4*lh
 249
 250
 251     # generation des strategies
 252     ciis_p = CIIS(random(),random(),random()/2,lh-1,2*lh)._genere()
 253     ciis_m = CIIS(random(),random(),random()/2,lm-1,lh)._genere()
 254     cip = CIIS(random(),random(),random()/2,lm-1,lh)._genere()
 255     S_p,S_m=[],[]
 256     S_c= [cip.next() for _ in xrange(nbit)]
 257
 258     date_m=[0]*lh
 259     for k in xrange(nbit):
 260         p = ciis_p.next()
 261         m = ciis_m.next()
 262         S_p += [p]
 263         S_m += [m]
 264
 265     #prour garantir Sp doit avoir au moins lm differentes valeurs
 266     dates_modif_suff = sample(xrange(1,nbit),lm)
 267     valeur_des_modifs=sample(xrange(lh),lm)
 268
 269     for i,e in enumerate(dates_modif_suff):
 270         S_p[e]=valeur_des_modifs[i]
 271
 272     for k in xrange(nbit):
 273         date_m[S_p[k]]=k
 274
 275
 276     #pour garantir que le message est present a la fin on modifie la strategie
 277     date_m=set(date_m)-set([0])
 278     m = sample(date_m,lm)
 279     for el in xrange(lm):
 280         d=m[el]
 281         S_c[d]= el
 282
 283
 284     for k in xrange(nbit):
 285         initiale_lscs_a_iterer[S_p[k]] = msg_init[S_c[k]]
 286         msg_init[S_m[k]] = f(S_m[k],msg_init)
 287
 288
 289     # Calcul du nombre de différences dans la matrice DWT
 290     str_acc += ";#lscs;" + str(diff(initiale_lscs_a_iterer,initiale_lscs))
 291
 292     marquee_matrice = embarque2(initiale_lscs_a_iterer,
 293                                 initiale_matrice,LSCs)
 294
 295     return (marquee_matrice,S_p,S_c,S_m,nbit)
 296
 297
 298
 299 def experience(nom_fichier):
 300     marquee_matrice = marque_matrice(nom_fichier)
 301
 302
 303     nbexp=10
 304     # matrices attaquees par rotation
 305     attaquee_matrice = []
 306     #print "rotations"
 307     for k in range(nbexp):
 308         at  = Attaque.rotation(marquee_matrice,
 309                                2*(k+1),
 310                                1)
 311         attaquee_matrice += [at]
 312
 313
 314     #print  "nombre d'attaques",len(attaquee_matrice)
 315
 316
 317 def extrait_message(S_p,S_c,S_m,x,lm,nbit):
 318     lh = len(x)
 319
 320     #recup derniere date de modif
 321     date_m=[0]*lh
 322     for k in xrange(nbit):
 323         date_m[S_p[k]]=k
 324
 325     mini = min(date_m)
 326     #suppression des iteration inutile: 0-> pair, 1-> impair
 327     marque = [0 for _ in xrange(lm)]
 328     S=[(-1,0)]*lh
 329     for k in xrange(mini):
 330         marque[S_m[k]] = f(S_m[k],marque)
 331     for k in xrange(mini,nbit):
 332         S[S_p[k]]= (S_c[k],marque[S_c[k]])
 333         marque[S_m[k]] = f(S_m[k],marque)
 334
 335     m=[[] for _ in xrange(lm)]
 336
 337     for k in xrange(lh):
 338         (v,p) = S[k]
 339         if v != -1 :
 340             m[v] += [(x[k]+p)%2]
 341
 342     mp=[]
 343     for l in m:
 344         k = average(l)
 345         if isnan(k) or isnan(round(k)):
 346             print "k",k
 347             print "S_p,",S_p
 348             print "S_c,",S_c
 349             print "S_m,",S_m
 350             print "x,",x
 351             print "lm,",lm
 352             print "nbit,",nbit
 353             print "l,",l
 354         else:
 355             mp+=[int(round(k))]
 356     return mp
 357
 358
 359
 360
 361 def msg_as_img(msg,name):
 362     lp = [0 if x == 0.0 else 255 for x in msg]
 363     at = im.new("L",(64,64))
 364     at.putdata(lp)
 365     at.save(name)
 366
 367 k=0
 368 def devine_si_est_marquee(mat_prob_att,mat_ref_et_suites,seuil,lm,msg):
 369     global k
 370     #print "mat ref...",mat_ref_et_suites
 371     (_,S_p,S_c,S_m,nbit) = mat_ref_et_suites
 372     x_lscs = matrice_lscs(matrice_to_bits(mat_prob_att),LSCs)
 373     msgr = extrait_message(S_p,S_c,S_m,x_lscs,lm,nbit)
 374
 375     #d = diff(msg,msgr)
 376     d = distance_rifqi(msg,msgr,0.1)
 377     if d < seuil :
 378         return 1
 379     else :
 380         return 0
 381
 382
 383 def trois_listes(l,marque):
 384     noms=["../../../../BCG10/Oxford11/experiments/images/"+str(n) for n in sample(range(1,3001),l)]
 385     marquees_et_suites = [get_marque_matrice(t,marque) for t in noms]
 386     marquees_puis_attaquees = [Attaque.alea(m) for (m,_,_,_,_) in marquees_et_suites]
 387     originales_puis_attaquees = [Attaque.alea(get_initiale_image(t)) for t in noms]
 388     return (marquees_et_suites,originales_puis_attaquees,marquees_puis_attaquees)
 389
 390 def construit_paire(marquees,originales_puis_attaquees,marquees_puis_attaquees,seuil,lm,msg):
 391     l = len(marquees_puis_attaquees)
 392     tp = sum([devine_si_est_marquee(marquees_puis_attaquees[t],marquees[t],seuil,lm,msg) for t in range(l)])
 393     fp = sum([devine_si_est_marquee(originales_puis_attaquees[t],marquees[t],seuil,lm,msg) for t in range(l)])
 394     fpr = fp /float(l)
 395     tpr = tp / float(l)
 396
 397     return (fpr,tpr)
 398
 399 def roc():
 400     file_msg  = "invader.png"
 401     message = [x if x==0 else 1 for x in im.open(file_msg).getdata()]
 402     l =[]
 403     (marquees,originales,attaquees) = trois_listes(20,message)
 404     nb_pts = 50
 405     for t in range(1,1+nb_pts):
 406         print t
 407         l +=[construit_paire(marquees,originales,attaquees,float(1.05)/nb_pts*t,len(message),message)]
 408
 409     return l
 410
 411 print roc()
 412