]> AND Private Git Repository - canny.git/blob - stc/exp/raphus/sobel555_for_ensemble.py
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
après raph
[canny.git] / 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()