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