stc/exp/raphus/sobel555_for_ensemble.py

   1 #-*- coding:utf-8 -*-
   2 import Image as im
   3 import numpy
   4 from sys import argv
   5 from pylab import *
   6 import string
   7 import cv
   8 import os
   9 from random import *
  10 from math import *
  11 from bbs import *
  12
  13
  14 infinity = 1000000000
  15 M=18532395500947174450709383384936679868383424444311405679463280782405796233163977*39688644836832882526173831577536117815818454437810437210221644553381995813014959
  16 X=18532395500947174450709383384936679868383424444311
  17
  18
  19
  20
  21
  22
  23
  24 # forward part
  25
  26
  27 def dec(ch,n):
  28     l = len(ch)
  29     acc = 0
  30     for i in xrange(l):
  31         if ch[i]==1:
  32             acc = acc + 2**(n-i-1)
  33     return acc
  34
  35
  36 def bin(elem,n):
  37     """Convertit un nombre en binaire"""
  38     q = -1
  39     res = [0 for i in xrange(n)]
  40     i = 1
  41     while q != 0:
  42         q = elem // 2
  43         r = elem % 2
  44         res[n-i] =  r
  45         elem = q
  46         i+=1
  47     return res
  48
  49
  50
  51 def xorb(a,b):
  52     return 1 if a != b else 0
  53
  54 def xor(e1,e2,h):
  55     e1b,e2b  = bin(e1,h),bin(e2,h)
  56     d = dec([xorb(e1b[j],e2b[j]) for j in xrange(h)],h)
  57     return d
  58
  59 def lit(d,(indx,indy)):
  60     if (indx,indy) in d :
  61         return d[(indx,indy)]
  62     else :
  63         return 0
  64
  65
  66
  67
  68 def forward(H_hat,x,message,lnm,rho):
  69     (h,w) = int(log(max(H_hat),2))+1, len(H_hat)
  70     path = dict()
  71     nbblock = lnm
  72     wght = [infinity for _ in xrange(int(2**h))]
  73     wght[0]=0
  74     newwght = [0 for _ in xrange(int(2**h))]
  75 #    rho = 1
  76 #    rho= [1 for _ in xrange(len(x))]
  77     indx,indm = 0,0
  78     i=0
  79     while i < nbblock: # pour chaque bit du message
  80         for j in xrange(w):   # pour chaque colonne de H_hat
  81             #print indx, "en entrant",wght
  82             k = 0
  83             while k < int(2**h): # pour chaque ligne de H
  84                 w0 = wght[k] + x[indx]*rho[indx]
  85                 w1 = wght[xor(k,H_hat[j],h)] + (1-x[indx])*rho[indx]
  86                 if w1 < w0 :
  87                     path[(indx,k)] = 1
  88                 else :
  89                     if (indx,k) in path:
  90                         del path[(indx,k)]
  91                 newwght[k] = min(w0,w1)
  92                 k +=1
  93             indx +=1
  94             wght = [t for t in newwght]
  95             #print " apres calcul",wght
  96
  97         for j in xrange(int(2**(h-1))):   # pour chaque colonne de H
  98             wght[j] = wght[2*j + message[indm]]
  99         wght = wght[:int(pow(2,h-1))] + [infinity for _ in xrange(int(pow(2,h)-pow(2,h-1)))]
 100         indm +=1
 101         i +=1
 102     start = np.argmin(wght)
 103     return (start,path)
 104
 105
 106 def backward(start,H_hat,x,message,lnm,path):
 107     (h,w) = int(log(max(H_hat),2))+1, len(H_hat)
 108     indx,indm = len(x)-1,lnm-1
 109     state = 2*start + message[indm]
 110     indm -=1
 111     # l'initialisation de state n'est pas optimale...
 112     nbblock = lnm
 113     y=np.zeros(len(x))
 114     i=0
 115     while i < nbblock:
 116         l = range(w)
 117         l.reverse()
 118         for j in l:   # pour chaque colonne de H_hat
 119             y[indx] = lit(path,(indx,state))
 120             state = xor(state,y[indx]*H_hat[j],h)
 121             indx -=1
 122         state = 2*state + message[indm]
 123         indm -=1
 124         i +=1
 125     return [int(t) for t in y]
 126
 127
 128
 129
 130
 131
 132 def trouve_H_hat(n,m,h):
 133     assert h ==7
 134     alpha = float(n)/m
 135     assert alpha >= 1
 136     index = min(int(alpha),9)
 137     mat = {
 138         1 : [127],
 139         2 : [71,109],
 140         3 : [95, 101, 121],
 141         4 : [81, 95, 107, 121],
 142         5 : [75, 95, 97, 105, 117],
 143         6 : [73, 83, 95, 103, 109, 123],
 144         7 : [69, 77, 93, 107, 111, 115, 121],
 145         8 : [69, 79, 81, 89, 93, 99, 107, 119],
 146         9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
 147         }[index]
 148     return(mat, index*m)
 149
 150
 151 def stc(x,rho,message):
 152     lnm = len(message)
 153     (mat,taille_suff) = trouve_H_hat(len(x),len(message),7)
 154     x_b = x[:taille_suff]
 155     (start,path) = forward(mat,x_b,message,lnm,rho)
 156     return (x_b,backward(start,mat,x_b,message,lnm,path),mat)
 157
 158
 159
 160
 161
 162 def nbdif(x,y):
 163     r,it = 0,0
 164     l = len(y)
 165     while it < l :
 166         if x[it] != y[it] :
 167             r +=1
 168         it += 1
 169     return float(r)/l
 170
 171
 172
 173
 174
 175
 176 def prod(H_hat,lnm,y):
 177     (h,w) = int(log(max(H_hat),2))+1, len(H_hat)
 178     i=0
 179     H =[]
 180     V=[0 for _ in range(len(y))]
 181     sol=[]
 182     while i < lnm: # pour chaque ligne
 183         V=[0 for _ in range(len(y))]
 184         k = max([(i-h+1)*w,0])
 185         dec = max([i-h+1,0])
 186         for j in xrange(min([i+1,h])): #nbre de blocks presents sur la ligne i
 187             for l in xrange(w): # pour chaque collone de H_hat
 188                 V[k] = bin(H_hat[l],h)[h-i-1+j+dec]
 189                 k+=1
 190
 191         sol.append(np.dot(np.array(V),np.array(y)))
 192         i+=1
 193         #H += [V]
 194     #H = np.array(H)
 195     #y = np.array(y)
 196     #print "dot",np.dot(H,y),H.shape
 197     #print "sol",sol
 198     return sol#list(np.dot(H,y))
 199
 200 def equiv(x,y):
 201     lx = len(x)
 202     assert lx == len(y)
 203     i=0
 204     while i < lx :
 205         if x[i] % 2 != y[i]%2 :
 206             return False
 207         i += 1
 208     return True
 209
 210
 211
 212
 213
 214
 215 def conversion(nombre, base, epsilon = 0.00001 ):
 216     ''' Soit nombre écrit en base 10, le retourne en base base'''
 217     if not 2 <= base <= 36:
 218         raise ValueError, "La base doit être entre 2 et 36"
 219     if not base == 2 and '.' in str(nombre):
 220         raise ValueError, "La partie décimale n'est pas gérée pour les bases\
 221                            différentes de 2."
 222     # IMPROVE : Convertir aussi la partie décimale, quand la base n'est pas égale
 223     # à 2.
 224     abc = string.digits + string.letters
 225     result = ''
 226     if nombre < 0:
 227         nombre = -nombre
 228         sign = '-'
 229     else:
 230         sign = ''
 231     if '.' in str(nombre):
 232         entier,decimal = int(str(nombre).split('.')[0]),\
 233                          float('.'+str(nombre).split('.')[1])
 234     else:
 235         entier,decimal = int(str(nombre)),0
 236     while entier !=0 :
 237         entier, rdigit = divmod( entier, base )
 238         result = abc[rdigit] + result
 239     flotante, decimalBin = 1./float(base),''
 240     while flotante > epsilon :
 241         if decimal >= flotante:
 242             decimalBin+='1'
 243             decimal-=flotante
 244         else :
 245             decimalBin+='0'
 246         flotante = flotante/float(base)
 247     if '1' in decimalBin :
 248         reste = '.'+decimalBin
 249         while reste[-1]=='0':
 250             reste = reste[:-1]
 251     else :
 252         reste = ''
 253     return sign + result + reste
 254
 255
 256 def getBit(X,pos):
 257     '''Récupère le bit en position pos de X.
 258     Par exemple, getBit(8,1) = 0, puisque le bit le plus à droite de 8 = 1000 est 0.
 259     On fera attention à ce que :
 260         - on compte à partir du point,
 261         - l'élément juste à gauche du point est en position 1,
 262         - celui juste à droite est en position -1.'''
 263     assert pos != 0
 264     entier = conversion(X,2)
 265     if '.' in entier:
 266         entier, decimal = entier.split('.')
 267         if decimal == '0':
 268             decimal = ''
 269     else:
 270         decimal = ''
 271     if '-' in entier:
 272         entier = entier.replace('-','')
 273     entier  = entier.zfill(abs(pos))
 274     decimal = (decimal+'0'*abs(pos))[:max(len(decimal),abs(pos))]
 275
 276     return int(entier[len(entier)-pos]) if pos >0 else int(decimal[-pos-1])
 277
 278
 279 def setBit(X,pos,y):
 280     '''Fixe le bit pos de X à la valeur y.
 281     Le fonctionnement est similaire à getBit :
 282         - on compte à partir du point,
 283         - l'élément juste à gauche du point est en position 1,
 284         - celui juste à droite est en position -1.'''
 285     assert pos != 0
 286     entier = conversion(X,2)
 287     if '.' in entier:
 288         entier, decimal = entier.split('.')
 289     else:
 290         decimal = ''
 291     entier  = list(entier.zfill(abs(pos)))
 292     decimal = list((decimal+'0'*abs(pos))[:max(len(decimal),abs(pos))])
 293     if pos>0:
 294         entier[len(entier)-pos]=str(int(y))
 295     else:
 296         decimal[-pos-1] = str(int(y))
 297     if decimal == []:
 298         return int(''.join(entier),2)
 299     else:
 300         S=0
 301         for k in range(len(decimal)):
 302             S += 1./2**(k+1)*int(decimal[k])
 303         return float(str(int(''.join(entier),2))+'.'+str(S).split('.')[1])
 304
 305
 306 def a2b(a):
 307     ai = ord(a)
 308     return ''.join('01'[(ai >> x) & 1] for x in xrange(7, -1, -1))
 309
 310
 311
 312 def a2b_list(L):
 313     LL=[]
 314     for i in L:
 315         for j in list(a2b(i)):
 316             LL.append(j)
 317     return LL
 318
 319
 320
 321 def toDecimal(x):
 322     return sum(map(lambda z: int(x[z]) and 2**(len(x) - z - 1),
 323                    range(len(x)-1, -1, -1)))
 324
 325 def conv_list_bit(L):
 326     L2=[]
 327     for j in range(len(L)/8):
 328         L2.append(chr(toDecimal("".join(L[j*8:(j+1)*8]))))
 329     return ''.join(L2)
 330
 331 def Denary2Binary(n):
 332     '''convert denary integer n to binary string bStr'''
 333     bStr = ''
 334     if n < 0:  raise ValueError, "must be a positive integer"
 335     if n == 0: return '0'
 336     while n > 0:
 337         bStr = str(n % 2) + bStr
 338         n = n >> 1
 339     return bStr
 340
 341
 342 def compute_filter_sobel(level,image):
 343     level2=level.copy()
 344     level2= array(level2.getdata()).flatten()
 345     l=0
 346     for x in level2:
 347         level2[l]=(x/2)*2
 348         l+=1
 349     level2_im=im.new('L',image.size)
 350     level2_im.putdata(level2)
 351
 352     cv_im = cv.CreateImageHeader(image.size, cv.IPL_DEPTH_8U, 1)
 353     cv.SetData(cv_im, level2_im.tostring())
 354     dst16 = cv.CreateImage(cv.GetSize(cv_im), cv.IPL_DEPTH_16S, 1)
 355
 356     laplace = cv.Sobel(cv_im, dst16,1, 1,7)
 357
 358     dst8 = cv.CreateImage (cv.GetSize(cv_im), cv.IPL_DEPTH_8U, 1)
 359     cv.ConvertScale(dst16,dst8)
 360     processed=im.fromstring("L", cv.GetSize(dst8), dst8.tostring())
 361 #    cv.ShowImage ('canny', dst8)
 362 #    cv.WaitKey()
 363
 364     return processed
 365
 366
 367
 368 def compute_list_bit_to_change(threshold,processed):
 369     List=[]
 370     nb=0
 371     l=0
 372     for i in processed:
 373         if (processed[l]>=threshold):
 374             #if nb%2==0:
 375                 List.append(l)
 376             #nb+=1
 377         l+=1
 378     return List
 379
 380
 381 def compute_filter_canny(level,image,MsgLen):
 382
 383     bbs = BlumBlumShub();
 384     bbs.setN(M)
 385     bbs.setSeed(X)
 386
 387     level2=level.copy()
 388     level2= array(level2.getdata()).flatten()
 389     l=0
 390     for x in level2:
 391         level2[l]=(x/2)*2
 392         l+=1
 393     level2_im=im.new('L',image.size)
 394     level2_im.putdata(level2)
 395     level2_im=im.merge("RGB",(level2_im,level2_im,level2_im))
 396 #    histo=level2_im.histogram()
 397     mean=numpy.mean(level2)
 398     std=numpy.std(level2)
 399
 400     cv_im = cv.CreateImageHeader(image.size, cv.IPL_DEPTH_8U, 3)
 401     cv.SetData(cv_im, level2_im.tostring())
 402
 403     yuv = cv.CreateImage(cv.GetSize(cv_im), 8, 3)
 404     gray = cv.CreateImage(cv.GetSize(cv_im), 8, 1)
 405     cv.CvtColor(cv_im, yuv, cv.CV_BGR2YCrCb)
 406     cv.Split(yuv, gray, None, None, None)
 407     #print 'mean',mean
 408     #print 'std',std
 409
 410     canny = cv.CreateImage(cv.GetSize(cv_im), 8, 1)
 411
 412     List_bit_to_change=set([])
 413     Weight=[]
 414
 415
 416
 417     cv.Canny(gray, canny, mean-1*std, mean+1*std,3)  #avant 10 255
 418     processed=im.fromstring("L", cv.GetSize(canny), canny.tostring())
 419     processed= array(processed.getdata()).flatten()
 420     List3=set(compute_list_bit_to_change(100,processed))
 421
 422     cv.Canny(gray, canny, mean-1*std, mean+1*std,5)  #avant 10 255
 423     processed=im.fromstring("L", cv.GetSize(canny), canny.tostring())
 424     processed= array(processed.getdata()).flatten()
 425     List5=set(compute_list_bit_to_change(100,processed))
 426
 427     cv.Canny(gray, canny, mean-1*std, mean+1*std,7)  #avant 10 255
 428     processed=im.fromstring("L", cv.GetSize(canny), canny.tostring())
 429     processed= array(processed.getdata()).flatten()
 430     List7=set(compute_list_bit_to_change(100,processed))
 431
 432     #nb_bit_embedded=(512*512/10)+40
 433     nb_bit_embedded=max(2*MsgLen,int(len(List3)/MsgLen)*MsgLen)
 434     print "nb_bit_embedded",nb_bit_embedded
 435     AvailablePixel3=List3
 436     AvailablePixel5=AvailablePixel3.union(List5)
 437     AvailablePixel7=AvailablePixel5.union(List7)
 438     sub=set()
 439
 440     if len(AvailablePixel3)>nb_bit_embedded:
 441         step=1
 442         WorkingPixel=AvailablePixel3
 443         sub = bbs.sample(AvailablePixel3,nb_bit_embedded)
 444     elif len(AvailablePixel5)>nb_bit_embedded:
 445         step=2
 446         WorkingPixel=AvailablePixel5
 447         sub = AvailablePixel3.union(
 448             bbs.sample(AvailablePixel5-AvailablePixel3,nb_bit_embedded-len(AvailablePixel3)))
 449
 450     elif len(AvailablePixel7)>nb_bit_embedded:
 451         step=3
 452         WorkingPixel=AvailablePixel7
 453         sub = AvailablePixel5.union(
 454             bbs.sample(AvailablePixel7-AvailablePixel5,nb_bit_embedded-len(AvailablePixel5)))
 455     else:
 456         step=4
 457         WorkingPixel=range(len(level2))
 458         sub = range(len(level2))
 459
 460
 461     #print "avail P3",len(AvailablePixel3)
 462     #print "avail P5",len(AvailablePixel5)
 463     #print "avail P7",len(AvailablePixel7)
 464
 465
 466     Weight=[0 for _ in sub]
 467
 468     l=0
 469     for i in sub:
 470         if step>=1 and i in List3:
 471             Weight[l]=1
 472         if step>=2 and i in List5 and Weight[l]==0:
 473             Weight[l]=10
 474         if step>=3 and i in List7 and Weight[l]==0:
 475             Weight[l]=100
 476         if step>=4 and Weight[l]==0:
 477             Weight[l]=1000
 478         l+=1
 479
 480     List_bit_to_change=sub
 481
 482
 483     return [sub,Weight]
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495 def mystego(filein, fileout):
 496     bit_to_read = 1
 497     global M,X
 498     bbs = BlumBlumShub();
 499     bbs.setN(M)
 500     bbs.setSeed(X)
 501
 502     dd = im.open(filein)
 503     dd = dd.convert('RGB')
 504     red, green, blue = dd.split()
 505     level=red.copy()
 506
 507
 508     """
 509
 510
 511     message="Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete  Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete  Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete  Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete  Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete voila c'est la fin blablabla:-)"
 512
 513     message="Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela. Bon voici un test avec un message un peu plus long. Bon j'en rajoute pour voir. Ce que j'écris est très original... Bref, je suis un poete   Salut christophe, arrives tu à lire ce message? normalement tu dois lire cela."
 514
 515
 516
 517
 518     leng_msg=len(message)
 519     print "taille du message en caracteres",leng_msg
 520     message=message+((leng_msg+7)/8*8-leng_msg)*" "
 521     leng_msg=len(message)
 522     leng='%08d'%len(message)
 523
 524     len_leng=len(leng)
 525     leng_error=int(len_leng)
 526     leng_cor=leng
 527
 528     List_pack=a2b_list(leng_cor)
 529     size=0
 530     for i in range(leng_msg/8):
 531         m=message[i*8:(i+1)*8]
 532         m_cor=m
 533         m_bin=a2b_list(m_cor)
 534         size=size+len(m_bin)
 535         List_pack.extend(m_bin)
 536
 537     """
 538
 539
 540
 541     message = []
 542     for c in [x if x==0 else 1 for x in im.open("invader.png").getdata()]:
 543         message +=[c]
 544
 545     leng_msg=len(message)
 546     leng='%08d'%len(message)
 547     len_leng=len(leng)
 548     leng_error=int(len_leng)
 549     leng_cor=leng
 550     List_pack=a2b_list(leng_cor)
 551     List_pack += message
 552     #print List_pack
 553
 554     leng_msg=len(List_pack)
 555
 556     [List_bit_to_change,Weight]=compute_filter_canny(level,dd,leng_msg)
 557     level= array(level.getdata()).flatten()
 558
 559     List_random=[]
 560     while len(List_random)<len(List_bit_to_change):
 561         List_random.extend(Denary2Binary(bbs.next()))
 562
 563
 564
 565     #print List_bit_to_change
 566     Support=[]
 567     for l in List_bit_to_change :
 568         Support += [getBit(level[l],bit_to_read) ]
 569
 570     #List_pack = message
 571
 572
 573     Message=[(int(List_pack[l])^int(List_random[l])) for l in xrange(len(List_pack))]
 574
 575     #print "support",len(List_bit_to_change)
 576     #print "message",len(Message)
 577     #print "weight",len(Weight)
 578
 579     (x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
 580
 581     #print "pourcentage modif",nbdif(x_b,Stc_message)
 582     #print "taille Stc_message",len(Stc_message)
 583 #    Stc_message=Message
 584
 585
 586     l=0
 587     size_mesg=0
 588     val_mod=0
 589     #print LL
 590
 591
 592     for l in List_bit_to_change:
 593         if(size_mesg<len(Stc_message)):
 594             b=getBit(level[l],bit_to_read)
 595             if b!=Stc_message[size_mesg]:
 596                 val_mod+=1
 597             level[l]=float64(setBit(level[l],bit_to_read,Stc_message[size_mesg]))
 598             size_mesg+=1
 599
 600     #print 'size mesg',size_mesg
 601     #print 'val mod',val_mod
 602     #print 'len message',len(Message),len(List_pack)
 603
 604
 605
 606     zz3=im.new('L',dd.size)
 607     zz3.putdata(level)
 608     #zz4=im.merge("RGB",(zz3, green, blue))
 609     zz3.save(fileout)
 610     #zz4.show()
 611
 612
 613     """
 614
 615     dd2 = im.open(fileout)
 616     dd2 = dd2.convert('RGB')
 617     red2, green, blue = dd2.split()
 618     level2=red2.copy()
 619
 620     [List_bit_to_change2,Weight2]=compute_filter_canny(level2,dd2,leng_msg)
 621
 622
 623     level2= array(level2.getdata()).flatten()
 624
 625     print "support2",len(List_bit_to_change2)
 626     print "message2",len(Message)
 627     print "weight2",len(Weight2)
 628
 629     alpha = float(len(List_bit_to_change2))/len(Message)
 630     assert alpha >= 2
 631     index = min(int(alpha),9)
 632     H_hat2 = {
 633         2 : [71,109],
 634         3 : [95, 101, 121],
 635         4 : [81, 95, 107, 121],
 636         5 : [75, 95, 97, 105, 117],
 637         6 : [73, 83, 95, 103, 109, 123],
 638         7 : [69, 77, 93, 107, 111, 115, 121],
 639         8 : [69, 79, 81, 89, 93, 99, 107, 119],
 640         9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
 641         }[index]
 642
 643
 644     print H_hat,H_hat2
 645
 646
 647     Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2]
 648     LL1=list(List_bit_to_change);
 649     LL2=list(List_bit_to_change2)
 650
 651     print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))])
 652     print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))])
 653     print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))])
 654
 655     Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)]
 656     level2=Message2
 657
 658 #    print "mesg",Message
 659 #    print "mesg2",Message2
 660
 661     print equiv(Message,Message2)
 662
 663     print "fini"
 664
 665     l=0
 666     val_mod2=0
 667     list_msg=[]
 668     decoded_msg=""
 669
 670     MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))]
 671 #    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))
 672 #    print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])))
 673
 674     print "MessageDecoded2",MessageDecoded2
 675     print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))]))
 676
 677
 678
 679
 680
 681
 682 #    for l in List_bit_to_change2:
 683 #        if(val_mod2<leng_error*8):
 684 #            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
 685 #            if(val_mod2==leng_error*8-1):
 686 #                bin_leng2=''.join(list_msg)
 687 #                coded_msg2=conv_list_bit(bin_leng2)
 688 #                clear_msg2=coded_msg2
 689 #                length_msg=int(clear_msg2)
 690 #                list_msg=[]
 691 #        if(val_mod2>=leng_error*8 and val_mod2<leng_error*8+length_msg*leng_error):
 692 #            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
 693 #            if(len(list_msg)==leng_error*8):
 694 #                pack=''.join(list_msg)
 695 #                msg=conv_list_bit(pack)
 696 #                decoded_msg=decoded_msg+msg
 697 #                list_msg=[]
 698 #        val_mod2+=1
 699 #        l=l+1
 700
 701     print decoded_msg#[0:20]
 702     print len(List_bit_to_change)
 703     list_nb_bit.append(filein)
 704     list_nb_bit.append(len(List_bit_to_change2))
 705
 706 """
 707
 708
 709 #path_cover = '/localhome/couturie/ensemble/cover_bad_laplace/'
 710 path_stego = '/home/couchot/rech/CCG12/canny/stc/exp/raphus/stego/'
 711 path_cover = '/home/couchot/rech/BCG10/Oxford11/experiments/images/'
 712 #path_stego = '/tmp/'
 713 #path_stego = '/home/couturie/BossBase-1.0-canny/'
 714 #listing = os.listdir(path_cover)
 715
 716
 717 list_nb_bit=[]
 718 l=0
 719
 720
 721
 722 # entree sortie
 723
 724
 725 listing = [957, 108, 106, 29, 431, 924, 262, 477, 346, 809]
 726
 727 for infile in listing:
 728 #    if l<10:
 729     fi = path_cover+str(infile)+'.png'
 730     fo = path_stego+str(infile)+'.png'
 731     mystego(fi,fo)
 732     l+=1
 733
 734 #f = open('histogram_boss_canny_100255', 'w')
 735 #f = open('histogram', 'w')
 736 #for item in list_nb_bit:
 737 #f.write("%s\n" % item)