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
 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 def verifie(fileout,leng_msg,Message,):
 493     global M,X
 494     bit_to_read = 1
 495     dd2 = im.open(fileout)
 496     dd2 = dd2.convert('RGB')
 497     red2, green, blue = dd2.split()
 498     level2=red2.copy()
 499
 500     [List_bit_to_change2,Weight2]=compute_filter_canny(level2,dd2,leng_msg)
 501
 502
 503     level2= array(level2.getdata()).flatten()
 504
 505     print "support2",len(List_bit_to_change2)
 506     print "message2",len(Message)
 507     print "weight2",len(Weight2)
 508
 509     alpha = float(len(List_bit_to_change2))/len(Message)
 510     assert alpha >= 2
 511     index = min(int(alpha),9)
 512     H_hat2 = {
 513         2 : [71,109],
 514         3 : [95, 101, 121],
 515         4 : [81, 95, 107, 121],
 516         5 : [75, 95, 97, 105, 117],
 517         6 : [73, 83, 95, 103, 109, 123],
 518         7 : [69, 77, 93, 107, 111, 115, 121],
 519         8 : [69, 79, 81, 89, 93, 99, 107, 119],
 520         9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
 521         }[index]
 522
 523
 524     print H_hat2
 525
 526
 527     Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2]
 528     LL2=list(List_bit_to_change2)
 529
 530     """
 531     print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))])
 532     print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))])
 533     print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))])
 534     """
 535     Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)]
 536     level2=Message2
 537
 538 #    print "mesg",Message
 539 #    print "mesg2",Message2
 540
 541     l=0
 542     val_mod2=0
 543     list_msg=[]
 544     decoded_msg=""
 545
 546
 547
 548     bbs = BlumBlumShub();
 549     bbs.setN(M)
 550     bbs.setSeed(X)
 551
 552     List_random=[]
 553     while len(List_random)<len(Message2):
 554         List_random.extend(Denary2Binary(bbs.next()))
 555
 556
 557
 558     MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))]
 559 #    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))
 560 #    print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])))
 561
 562     #print "MessageDecoded2",MessageDecoded2
 563
 564     outIm = im.new("L",im.open("invader.png").size)
 565     (l,h) = outIm.size
 566     print "taille de l'image",l*h
 567     print "taille des donneées",len(MessageDecoded2)
 568     queue = [255 if x != 0 else 0 for x in MessageDecoded2]
 569     queue = queue[len(queue)-l*h:]
 570     outIm.putdata(queue)
 571     outIm.save("apresSobel.png")
 572
 573 """
 574     print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))]))
 575    for l in List_bit_to_change2:
 576        if(val_mod2<leng_error*8):
 577            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
 578            if(val_mod2==leng_error*8-1):
 579                bin_leng2=''.join(list_msg)
 580                coded_msg2=conv_list_bit(bin_leng2)
 581                clear_msg2=coded_msg2
 582                length_msg=int(clear_msg2)
 583                list_msg=[]
 584        if(val_mod2>=leng_error*8 and val_mod2<leng_error*8+length_msg*leng_error):
 585            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
 586            if(len(list_msg)==leng_error*8):
 587                pack=''.join(list_msg)
 588                msg=conv_list_bit(pack)
 589                decoded_msg=decoded_msg+msg
 590                list_msg=[]
 591        val_mod2+=1
 592        l=l+1
 593        print decoded_msg#[0:20]
 594 """
 595
 596
 597
 598
 599
 600 def mystego(filein, fileout,file_msg="invader"):
 601     bit_to_read = 1
 602     global M,X
 603     bbs = BlumBlumShub();
 604     bbs.setN(M)
 605     bbs.setSeed(X)
 606
 607     dd = im.open(filein)
 608     dd = dd.convert('RGB')
 609     red, green, blue = dd.split()
 610     level=red.copy()
 611
 612     #print type(level),level
 613
 614
 615     """
 616
 617
 618     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:-)"
 619
 620     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."
 621
 622
 623
 624
 625     leng_msg=len(message)
 626     print "taille du message en caracteres",leng_msg
 627     message=message+((leng_msg+7)/8*8-leng_msg)*" "
 628     leng_msg=len(message)
 629     leng='%08d'%len(message)
 630
 631     len_leng=len(leng)
 632     leng_error=int(len_leng)
 633     leng_cor=leng
 634
 635     List_pack=a2b_list(leng_cor)
 636     size=0
 637     for i in range(leng_msg/8):
 638         m=message[i*8:(i+1)*8]
 639         m_cor=m
 640         m_bin=a2b_list(m_cor)
 641         size=size+len(m_bin)
 642         List_pack.extend(m_bin)
 643
 644     """
 645
 646
 647
 648     message = []
 649     for c in [x if x==0 else 1 for x in im.open("invader.png").getdata()]:
 650         message +=[c]
 651
 652     leng_msg=len(message)
 653     leng='%08d'%len(message)
 654     len_leng=len(leng)
 655     leng_error=int(len_leng)
 656     leng_cor=leng
 657     List_pack=a2b_list(leng_cor)
 658     List_pack += message
 659     #print List_pack
 660
 661     leng_msg=len(List_pack)
 662     print "leng_msg",leng_msg
 663
 664     [List_bit_to_change,Weight]=compute_filter_canny(level,dd,leng_msg)
 665     level= array(level.getdata()).flatten()
 666
 667     List_random=[]
 668     while len(List_random)<len(List_pack):
 669         List_random.extend(Denary2Binary(bbs.next()))
 670
 671
 672
 673     #print List_bit_to_change
 674     Support=[]
 675     for l in List_bit_to_change :
 676         Support += [getBit(level[l],bit_to_read) ]
 677
 678     #List_pack = message
 679
 680
 681     Message=[(int(List_pack[l])^int(List_random[l])) for l in xrange(len(List_pack))]
 682
 683     #print "support",len(List_bit_to_change)
 684     #print "message",Message
 685     #print "weight",len(Weight)
 686
 687     #(x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
 688
 689     (x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
 690
 691     print "comparaison entre stc_message et message", len(Stc_message),len(Message)
 692
 693
 694     #print "pourcentage modif",nbdif(x_b,Stc_message)
 695     #print "taille Stc_message",len(Stc_message)
 696 #    Stc_message=Message
 697
 698
 699     l=0
 700     size_mesg=0
 701     val_mod=0
 702     #print LL
 703
 704
 705     for l in List_bit_to_change:
 706         if(size_mesg<len(Stc_message)):
 707             b=getBit(level[l],bit_to_read)
 708             if b!=Stc_message[size_mesg]:
 709                 val_mod+=1
 710             level[l]=float64(setBit(level[l],bit_to_read,Stc_message[size_mesg]))
 711             size_mesg+=1
 712
 713     #print 'size mesg',size_mesg
 714     #print 'val mod',val_mod
 715     #print 'len message',len(Message),len(List_pack)
 716
 717
 718
 719     zz3=im.new('L',dd.size)
 720     zz3.putdata(level)
 721     #zz4=im.merge("RGB",(zz3, green, blue))
 722     zz3.save(fileout)
 723     #zz4.show()
 724
 725     verifie(fileout,leng_msg,Message)
 726
 727
 728
 729
 730
 731 # entree sortie
 732 def main():
 733     path_stego = '/home/couchot/rech/CCG12/canny/stc/exp/raphus/stego/'
 734     path_cover = '/home/couchot/rech/BCG10/Oxford11/experiments/images/'
 735     list_nb_bit=[]
 736     l=0
 737     listing = [957, 108, 106, 29, 431, 924, 262, 477, 346, 809]
 738     for infile in listing:
 739         #    if l<10:
 740         fi = path_cover+str(infile)+'.png'
 741         fo = path_stego+str(infile)+'.png'
 742         mystego(fi,fo)
 743         l+=1
 744
 745 if __name__ == "__main__":
 746     main()