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)+40
 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     message = ""
 517     for c in [x if x==0 else 1 for x in im.open("invader.png").getdata()]:
 518         message +=str(c)
 519
 520     print message
 521     """
 522
 523     leng_msg=len(message)
 524     print "taille du message en caracteres",leng_msg
 525     message=message+((leng_msg+7)/8*8-leng_msg)*" "
 526     leng_msg=len(message)
 527     leng='%08d'%len(message)
 528
 529     len_leng=len(leng)
 530     leng_error=int(len_leng)
 531     leng_cor=leng
 532
 533     List_pack=a2b_list(leng_cor)
 534     size=0
 535     for i in range(leng_msg/8):
 536         m=message[i*8:(i+1)*8]
 537         m_cor=m
 538         m_bin=a2b_list(m_cor)
 539         size=size+len(m_bin)
 540         List_pack.extend(m_bin)
 541
 542
 543     leng_msg=len(List_pack)
 544
 545     [List_bit_to_change,Weight]=compute_filter_canny(level,dd,leng_msg)
 546     level= array(level.getdata()).flatten()
 547
 548     List_random=[]
 549     while len(List_random)<len(List_bit_to_change):
 550         List_random.extend(Denary2Binary(bbs.next()))
 551
 552
 553
 554     #print List_bit_to_change
 555     Support=[]
 556     for l in List_bit_to_change :
 557         Support += [getBit(level[l],bit_to_read) ]
 558     #print len(List_pack)
 559     #List_pack = message
 560
 561
 562     Message=[(int(List_pack[l])^int(List_random[l])) for l in xrange(len(List_pack))]
 563
 564     print "support",len(List_bit_to_change)
 565     print "message",len(Message)
 566     print "weight",len(Weight)
 567
 568     (x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
 569
 570     print "pourcentage modif",nbdif(x_b,Stc_message)
 571     print "taille Stc_message",len(Stc_message)
 572 #    Stc_message=Message
 573
 574
 575     l=0
 576     size_mesg=0
 577     val_mod=0
 578     #print LL
 579
 580
 581     for l in List_bit_to_change:
 582         if(size_mesg<len(Stc_message)):
 583             b=getBit(level[l],bit_to_read)
 584             if b!=Stc_message[size_mesg]:
 585                 val_mod+=1
 586             level[l]=float64(setBit(level[l],bit_to_read,Stc_message[size_mesg]))
 587             size_mesg+=1
 588
 589     print 'size mesg',size_mesg
 590     print 'val mod',val_mod
 591     print 'len message',len(Message),len(List_pack)
 592
 593
 594
 595     zz3=im.new('L',dd.size)
 596     zz3.putdata(level)
 597     #zz4=im.merge("RGB",(zz3, green, blue))
 598     zz3.save(fileout)
 599     #zz4.show()
 600
 601
 602
 603
 604     dd2 = im.open(fileout)
 605     dd2 = dd2.convert('RGB')
 606     red2, green, blue = dd2.split()
 607     level2=red2.copy()
 608
 609     [List_bit_to_change2,Weight2]=compute_filter_canny(level2,dd2,leng_msg)
 610
 611
 612     level2= array(level2.getdata()).flatten()
 613
 614     print "support2",len(List_bit_to_change2)
 615     print "message2",len(Message)
 616     print "weight2",len(Weight2)
 617
 618     alpha = float(len(List_bit_to_change2))/len(Message)
 619     assert alpha >= 2
 620     index = min(int(alpha),9)
 621     H_hat2 = {
 622         2 : [71,109],
 623         3 : [95, 101, 121],
 624         4 : [81, 95, 107, 121],
 625         5 : [75, 95, 97, 105, 117],
 626         6 : [73, 83, 95, 103, 109, 123],
 627         7 : [69, 77, 93, 107, 111, 115, 121],
 628         8 : [69, 79, 81, 89, 93, 99, 107, 119],
 629         9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
 630         }[index]
 631
 632
 633     print H_hat,H_hat2
 634
 635
 636     Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2]
 637     LL1=list(List_bit_to_change);
 638     LL2=list(List_bit_to_change2)
 639
 640     print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))])
 641     print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))])
 642     print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))])
 643
 644     Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)]
 645     level2=Message2
 646
 647 #    print "mesg",Message
 648 #    print "mesg2",Message2
 649
 650     print equiv(Message,Message2)
 651
 652     print "fini"
 653
 654     l=0
 655     val_mod2=0
 656     list_msg=[]
 657     decoded_msg=""
 658
 659     MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))]
 660 #    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))
 661 #    print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])))
 662
 663     print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))]))
 664
 665
 666
 667
 668
 669
 670 #    for l in List_bit_to_change2:
 671 #        if(val_mod2<leng_error*8):
 672 #            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
 673 #            if(val_mod2==leng_error*8-1):
 674 #                bin_leng2=''.join(list_msg)
 675 #                coded_msg2=conv_list_bit(bin_leng2)
 676 #                clear_msg2=coded_msg2
 677 #                length_msg=int(clear_msg2)
 678 #                list_msg=[]
 679 #        if(val_mod2>=leng_error*8 and val_mod2<leng_error*8+length_msg*leng_error):
 680 #            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
 681 #            if(len(list_msg)==leng_error*8):
 682 #                pack=''.join(list_msg)
 683 #                msg=conv_list_bit(pack)
 684 #                decoded_msg=decoded_msg+msg
 685 #                list_msg=[]
 686 #        val_mod2+=1
 687 #        l=l+1
 688
 689     print decoded_msg#[0:20]
 690     print len(List_bit_to_change)
 691     list_nb_bit.append(filein)
 692     list_nb_bit.append(len(List_bit_to_change2))
 693
 694
 695
 696
 697 #path_cover = '/localhome/couturie/ensemble/cover_bad_laplace/'
 698 path_stego = '/localhome/couturie/ensemble/BossBase-1.0-canny_new/'
 699 path_cover = '/localhome/couturie/ensemble/BossBase-1.0-cover/'
 700 #path_stego = '/tmp/'
 701 #path_stego = '/home/couturie/BossBase-1.0-canny/'
 702 #listing = os.listdir(path_cover)
 703
 704 list_nb_bit=[]
 705 l=0
 706
 707
 708 mystego(argv[1],argv[2])
 709 # entree sortie
 710
 711 raise SystemExit
 712
 713 for infile in listing:
 714 #    if l<10:
 715     if infile[0]==argv[1]:
 716         print "current file is: " + infile, path_stego+infile
 717         mystego(path_cover+infile,path_stego+infile)
 718     l+=1
 719
 720 #f = open('histogram_boss_canny_100255', 'w')
 721 #f = open('histogram', 'w')
 722 #for item in list_nb_bit:
 723 #  f.write("%s\n" % item)