]> AND Private Git Repository - canny.git/commitdiff
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
reprise des négociations
authorcouchot <couchot@couchot-Latitude-E6320.(none)>
Tue, 2 Oct 2012 13:55:22 +0000 (15:55 +0200)
committercouchot <couchot@couchot-Latitude-E6320.(none)>
Tue, 2 Oct 2012 13:55:22 +0000 (15:55 +0200)
17 files changed:
biblio.bib
main.tex
ourapproach.tex
stc/exp/raphus/attaque.py [new file with mode: 0755]
stc/exp/raphus/attaques.py [new file with mode: 0644]
stc/exp/raphus/script_attaques.py [new file with mode: 0644]
stc/exp/raphus/sobel555_for_ensemble.py
stc/exp/raphus/stego/106.png
stc/exp/raphus/stego/108.png
stc/exp/raphus/stego/262.png
stc/exp/raphus/stego/29.png
stc/exp/raphus/stego/346.png
stc/exp/raphus/stego/431.png
stc/exp/raphus/stego/477.png
stc/exp/raphus/stego/809.png
stc/exp/raphus/stego/924.png
stc/exp/raphus/stego/957.png

index bfb99b102b08d629f09b52e2a540de16e8b1a9bd..47c0c0038d288badd2b9a353e93c5cc76d66cb4c 100644 (file)
@@ -2,7 +2,7 @@
  author = {Dumitrescu, Sorina and Wu, Xiaolin},
  title = {LSB steganalysis based on high-order statistics},
  booktitle = {Proceedings of the 7th workshop on Multimedia and security},
  author = {Dumitrescu, Sorina and Wu, Xiaolin},
  title = {LSB steganalysis based on high-order statistics},
  booktitle = {Proceedings of the 7th workshop on Multimedia and security},
- series = {MM\&\#38;Sec '05},
+ series = {MMSec '05},
  year = {2005},
  isbn = {1-59593-032-9},
  location = {New York, NY, USA},
  year = {2005},
  isbn = {1-59593-032-9},
  location = {New York, NY, USA},
@@ -54,3 +54,323 @@ author    = {Jessica J. Fridrich and
  note = {to appear}
 }
 
  note = {to appear}
 }
 
+@article{DBLP:journals/tsp/DumitrescuWW03,
+  added-at = {2012-02-06T00:00:00.000+0100},
+  author = {Dumitrescu, Sorina and Wu, Xiaolin and Wang, Zhe},
+  biburl = {http://www.bibsonomy.org/bibtex/2556caad9b61980d3458885153a52321c/dblp},
+  ee = {http://dx.doi.org/10.1109/TSP.2003.812753},
+  interhash = {f51bec0b4e4f8aba644eb0938018d2c6},
+  intrahash = {556caad9b61980d3458885153a52321c},
+  journal = {IEEE Transactions on Signal Processing},
+  keywords = {dblp},
+  number = 7,
+  pages = {1995-2007},
+  timestamp = {2012-02-06T00:00:00.000+0100},
+  title = {Detection of LSB steganography via sample pair analysis.},
+  url = {http://dblp.uni-trier.de/db/journals/tsp/tsp51.html#DumitrescuWW03},
+  volume = 51,
+  year = 2003
+}
+
+@inproceedings{DBLP:conf/mmsec/FridrichGD01,
+  added-at = {2007-10-26T00:00:00.000+0200},
+  author = {Fridrich, Jessica J. and Goljan, Miroslav and Du, Rui},
+  biburl = {http://www.bibsonomy.org/bibtex/21c12d6fb5f949f98fabe4ee75cab4f8b/dblp},
+  booktitle = {MMSec},
+  crossref = {DBLP:conf/mmsec/2001},
+  date = {2007-10-26},
+  description = {dblp},
+  editor = {Georganas, Nicolas D. and Popescu-Zeletin, Radu},
+  ee = {http://doi.acm.org/10.1145/1232454.1232466},
+  interhash = {de49b3b9958119616eee66f14060f47f},
+  intrahash = {1c12d6fb5f949f98fabe4ee75cab4f8b},
+  isbn = {1-58113-393-6},
+  keywords = {dblp},
+  pages = {27-30},
+  publisher = {ACM},
+  timestamp = {2007-10-26T00:00:00.000+0200},
+  title = {Reliable detection of LSB steganography in color and grayscale images.},
+  url = {http://dblp.uni-trier.de/db/conf/mmsec/mmsec2001.html#FridrichGD01},
+  year = 2001
+}
+
+
+@proceedings{DBLP:conf/mmsec/2001,
+  editor    = {Nicolas D. Georganas and
+               Radu Popescu-Zeletin},
+  title     = {Proceedings of the 4th workshop on Multimedia {\&} Security:
+               New Challenges, MM{\&}Sec 2001, Ottawa, Ontario, Canada,
+               October 5, 2001},
+  booktitle = {MM{\&}Sec},
+  publisher = {ACM},
+  year      = {2001},
+  isbn      = {1-58113-393-6},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+@inproceedings{DBLP:conf/ih/PevnyFB10,
+  added-at = {2010-10-08T00:00:00.000+0200},
+  author = {Pevný, Tomás and Filler, Tomás and Bas, Patrick},
+  biburl = {http://www.bibsonomy.org/bibtex/28d83b7eac2c22ed5e7e072fd43a34248/dblp},
+  booktitle = {Information Hiding},
+  crossref = {DBLP:conf/ih/2010},
+  editor = {Böhme, Rainer and Fong, Philip W. L. and Safavi-Naini, Reihaneh},
+  ee = {http://dx.doi.org/10.1007/978-3-642-16435-4_13},
+  interhash = {b30869c1bb39a2c15b33e05e5139e58b},
+  intrahash = {8d83b7eac2c22ed5e7e072fd43a34248},
+  isbn = {978-3-642-16434-7},
+  keywords = {dblp},
+  pages = {161-177},
+  publisher = {Springer},
+  series = {Lecture Notes in Computer Science},
+  timestamp = {2010-10-08T00:00:00.000+0200},
+  title = {Using High-Dimensional Image Models to Perform Highly Undetectable Steganography.},
+  url = {http://dblp.uni-trier.de/db/conf/ih/ih2010.html#PevnyFB10},
+  volume = 6387,
+  year = 2010
+}
+
+@proceedings{DBLP:conf/ih/2010,
+  editor    = {Rainer B{\"o}hme and
+               Philip W. L. Fong and
+               Reihaneh Safavi-Naini},
+  title     = {Information Hiding - 12th International Conference, IH 2010,
+               Calgary, AB, Canada, June 28-30, 2010, Revised Selected
+               Papers},
+  booktitle = {Information Hiding},
+  publisher = {Springer},
+  series    = {Lecture Notes in Computer Science},
+  volume    = {6387},
+  year      = {2010},
+  isbn      = {978-3-642-16434-7},
+  ee        = {http://dx.doi.org/10.1007/978-3-642-16435-4},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+
+@article{DBLP:journals/eswa/ChenCL10,
+  added-at = {2010-07-21T15:44:10.000+0200},
+  author = {Chen, Wen-Jan and Chang, Chin-Chen and Le, T. Hoang Ngan},
+  biburl = {http://www.bibsonomy.org/bibtex/228889a4ab329da28559f0910469f054b/dblp},
+  date = {2010-05-03},
+  ee = {http://dx.doi.org/10.1016/j.eswa.2009.09.050},
+  interhash = {bc34a5f04661fee24ee62c39e76361be},
+  intrahash = {28889a4ab329da28559f0910469f054b},
+  journal = {Expert Syst. Appl.},
+  keywords = {dblp},
+  number = 4,
+  pages = {3292-3301},
+  timestamp = {2010-07-21T15:44:10.000+0200},
+  title = {High payload steganography mechanism using hybrid edge detector.},
+  url = {http://dblp.uni-trier.de/db/journals/eswa/eswa37.html#ChenCL10},
+  volume = 37,
+  year = 2010
+}
+
+@article{DBLP:journals/tifs/FillerJF11,
+  added-at = {2011-09-29T00:00:00.000+0200},
+  author = {Filler, Tomás and Judas, Jan and Fridrich, Jessica J.},
+  biburl = {http://www.bibsonomy.org/bibtex/250e43c05a74eec17524b3df8db442da5/dblp},
+  ee = {http://dx.doi.org/10.1109/TIFS.2011.2134094},
+  interhash = {b27d23ed0c9936d568e16c51378abccd},
+  intrahash = {50e43c05a74eec17524b3df8db442da5},
+  journal = {IEEE Transactions on Information Forensics and Security},
+  keywords = {dblp},
+  number = {3-2},
+  pages = {920-935},
+  timestamp = {2011-09-29T00:00:00.000+0200},
+  title = {Minimizing Additive Distortion in Steganography Using Syndrome-Trellis Codes.},
+  url = {http://dblp.uni-trier.de/db/journals/tifs/tifs6.html#FillerJF11},
+  volume = 6,
+  year = 2011
+}
+
+
+
+@inproceedings{DBLP:conf/ih/Westfeld01,
+  added-at = {2011-06-28T00:00:00.000+0200},
+  author = {Westfeld, Andreas},
+  biburl = {http://www.bibsonomy.org/bibtex/2fea2c6aabf7eba19ceaec93f913e5d8d/dblp},
+  booktitle = {Information Hiding},
+  crossref = {DBLP:conf/ih/2001},
+  editor = {Moskowitz, Ira S.},
+  ee = {http://dx.doi.org/10.1007/3-540-45496-9_21},
+  interhash = {e7eaa917e995dc9373f10304d3e79255},
+  intrahash = {fea2c6aabf7eba19ceaec93f913e5d8d},
+  isbn = {3-540-42733-3},
+  keywords = {dblp},
+  pages = {289-302},
+  publisher = {Springer},
+  series = {Lecture Notes in Computer Science},
+  timestamp = {2011-06-28T00:00:00.000+0200},
+  title = {F5-A Steganographic Algorithm.},
+  url = {http://dblp.uni-trier.de/db/conf/ih/ihw2001.html#Westfeld01},
+  volume = 2137,
+  year = 2001
+}
+
+@proceedings{DBLP:conf/ih/2001,
+  editor    = {Ira S. Moskowitz},
+  title     = {Information Hiding, 4th International Workshop, IHW 2001,
+               Pittsburgh, PA, USA, April 25-27, 2001, Proceedings},
+  booktitle = {Information Hiding},
+  publisher = {Springer},
+  series    = {Lecture Notes in Computer Science},
+  volume    = {2137},
+  year      = {2001},
+  isbn      = {3-540-42733-3},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+@inproceedings{DBLP:conf/ih/KimDR06,
+  added-at = {2007-09-20T00:00:00.000+0200},
+  author = {Kim, Younhee and Duric, Zoran and Richards, Dana},
+  biburl = {http://www.bibsonomy.org/bibtex/2f0324f70d62d9dfba568e393920aaa16/dblp},
+  booktitle = {Information Hiding},
+  crossref = {DBLP:conf/ih/2006},
+  date = {2007-09-20},
+  description = {dblp},
+  editor = {Camenisch, Jan and Collberg, Christian S. and Johnson, Neil F. and Sallee, Phil},
+  ee = {http://dx.doi.org/10.1007/978-3-540-74124-4_21},
+  interhash = {399aab122b39cfd6f6e951a1b276c786},
+  intrahash = {f0324f70d62d9dfba568e393920aaa16},
+  isbn = {978-3-540-74123-7},
+  keywords = {dblp},
+  pages = {314-327},
+  publisher = {Springer},
+  series = {Lecture Notes in Computer Science},
+  timestamp = {2007-09-20T00:00:00.000+0200},
+  title = {Modified Matrix Encoding Technique for Minimal Distortion Steganography.},
+  url = {http://dblp.uni-trier.de/db/conf/ih/ih2006.html#KimDR06},
+  volume = 4437,
+  year = 2006
+}
+
+
+@proceedings{DBLP:conf/ih/2006,
+  editor    = {Jan Camenisch and
+               Christian S. Collberg and
+               Neil F. Johnson and
+               Phil Sallee},
+  title     = {Information Hiding, 8th International Workshop, IH 2006,
+               Alexandria, VA, USA, July 10-12, 2006. Revised Selcted Papers},
+  booktitle = {Information Hiding},
+  publisher = {Springer},
+  series    = {Lecture Notes in Computer Science},
+  volume    = {4437},
+  year      = {2007},
+  isbn      = {978-3-540-74123-7},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+@inproceedings{DBLP:conf/mmsec/FridrichPK07,
+  added-at = {2007-10-26T00:00:00.000+0200},
+  author = {Fridrich, Jessica J. and Pevný, Tomás and Kodovský, Jan},
+  biburl = {http://www.bibsonomy.org/bibtex/26123ac512b5e1fe72a44e73d101d8b95/dblp},
+  booktitle = {MMSec},
+  crossref = {DBLP:conf/mmsec/2007},
+  date = {2007-10-26},
+  description = {dblp},
+  editor = {Kundur, Deepa and Prabhakaran, Balakrishnan and Dittmann, Jana and Fridrich, Jessica J.},
+  ee = {http://doi.acm.org/10.1145/1288869.1288872},
+  interhash = {35c4a20b41b7861bcb09c9ff335ac601},
+  intrahash = {6123ac512b5e1fe72a44e73d101d8b95},
+  isbn = {978-1-59593-857-2},
+  keywords = {dblp},
+  pages = {3-14},
+  publisher = {ACM},
+  timestamp = {2007-10-26T00:00:00.000+0200},
+  title = {Statistically undetectable jpeg steganography: dead ends challenges, and opportunities.},
+  url = {http://dblp.uni-trier.de/db/conf/mmsec/mmsec2007.html#FridrichPK07},
+  year = 2007
+}
+
+@proceedings{DBLP:conf/mmsec/2007,
+  editor    = {Deepa Kundur and
+               Balakrishnan Prabhakaran and
+               Jana Dittmann and
+               Jessica J. Fridrich},
+  title     = {Proceedings of the 9th workshop on Multimedia {\&} Security,
+               MM{\&}Sec 2007, Dallas, Texas, USA, September 20-21, 2007},
+  booktitle = {MM{\&}Sec},
+  publisher = {ACM},
+  year      = {2007},
+  isbn      = {978-1-59593-857-2},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+@inproceedings{DBLP:conf/mediaforensics/FillerJF10,
+  added-at = {2010-08-21T00:00:00.000+0200},
+  author = {Filler, Tomás and Judas, Jan and Fridrich, Jessica J.},
+  biburl = {http://www.bibsonomy.org/bibtex/23405985533dce431b5013941a2c2c2cc/dblp},
+  booktitle = {Media Forensics and Security},
+  crossref = {DBLP:conf/mediaforensics/2010},
+  editor = {Memon, Nasir D. and Dittmann, Jana and Alattar, Adnan M. and Delp, Edward J.},
+  ee = {http://dx.doi.org/10.1117/12.838002},
+  interhash = {a3d2215b959361a30f0b48f15c012bc9},
+  intrahash = {3405985533dce431b5013941a2c2c2cc},
+  isbn = {978-0-8194-7934-1},
+  keywords = {dblp},
+  pages = 754105,
+  publisher = {SPIE},
+  series = {SPIE Proceedings},
+  timestamp = {2010-08-21T00:00:00.000+0200},
+  title = {Minimizing embedding impact in steganography using trellis-coded quantization.},
+  url = {http://dblp.uni-trier.de/db/conf/mediaforensics/mediaforensics2010.html#FillerJF10},
+  volume = 7541,
+  year = 2010
+}
+
+
+@proceedings{DBLP:conf/mediaforensics/2010,
+  editor    = {Nasir D. Memon and
+               Jana Dittmann and
+               Adnan M. Alattar and
+               Edward J. Delp},
+  title     = {Media Forensics and Security II, part of the IS{\&}T-SPIE
+               Electronic Imaging Symposium, San Jose, CA, USA, January
+               18-20, 2010, Proceedings},
+  booktitle = {Media Forensics and Security},
+  publisher = {SPIE},
+  series    = {SPIE Proceedings},
+  volume    = {7541},
+  year      = {2010},
+  isbn      = {978-0-8194-7934-1},
+  bibsource = {DBLP, http://dblp.uni-trier.de}
+}
+
+
+@article{Luo:2010:EAI:1824719.1824720,
+ author = {Luo, Weiqi and Huang, Fangjun and Huang, Jiwu},
+ title = {Edge adaptive image steganography based on LSB matching revisited},
+ journal = {Trans. Info. For. Sec.},
+ issue_date = {June 2010},
+ volume = {5},
+ number = {2},
+ month = jun,
+ year = {2010},
+ issn = {1556-6013},
+ pages = {201--214},
+ numpages = {14},
+ url = {http://dx.doi.org/10.1109/TIFS.2010.2041812},
+ doi = {10.1109/TIFS.2010.2041812},
+ acmid = {1824720},
+ publisher = {IEEE Press},
+ address = {Piscataway, NJ, USA},
+ keywords = {Content-based steganography, content-based steganography, least-significant-bit (LSB)-based steganography, pixel-value differencing (PVD), security, steganalysis},
+} 
+
+@article{Mielikainen06,
+  author =      {Mielikainen, J.},
+  title =       {LSB Matching Revisited},
+  journal =     {Signal Processing Letters},
+  year =        {2006},
+  OPTkey =      {},
+  volume =      {13},
+  number =      {5},
+  pages =       {285--287},
+  month =       may,
+  OPTnote =     {},
+  OPTannote =   {}
+}
+
index a175e8a1674d095fb54461f219c7f690df9281e2..fcbcdbbe98dcdf9c473269a00b7bb75908e05bce 100755 (executable)
--- a/main.tex
+++ b/main.tex
@@ -1,324 +1,7 @@
 \documentclass[draft,journal]{IEEEtran}
 \documentclass[draft,journal]{IEEEtran}
-%
-% If IEEEtran.cls has not been installed into the LaTeX system files,
-% manually specify the path to it like:
-% \documentclass[journal]{../sty/IEEEtran}
-
-
-
-
-
-% Some very useful LaTeX packages include:
-% (uncomment the ones you want to load)
-
-
-% *** MISC UTILITY PACKAGES ***
-%
-%\usepackage{ifpdf}
-% Heiko Oberdiek's ifpdf.sty is very useful if you need conditional
-% compilation based on whether the output is pdf or dvi.
-% usage:
-% \ifpdf
-%   % pdf code
-% \else
-%   % dvi code
-% \fi
-% The latest version of ifpdf.sty can be obtained from:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/oberdiek/
-% Also, note that IEEEtran.cls V1.7 and later provides a builtin
-% \ifCLASSINFOpdf conditional that works the same way.
-% When switching from latex to pdflatex and vice-versa, the compiler may
-% have to be run twice to clear warning/error messages.
-
-
-
-
-
-
-% *** CITATION PACKAGES ***
-%
-%\usepackage{cite}
-% cite.sty was written by Donald Arseneau
-% V1.6 and later of IEEEtran pre-defines the format of the cite.sty package
-% \cite{} output to follow that of IEEE. Loading the cite package will
-% result in citation numbers being automatically sorted and properly
-% "compressed/ranged". e.g., [1], [9], [2], [7], [5], [6] without using
-% cite.sty will become [1], [2], [5]--[7], [9] using cite.sty. cite.sty's
-% \cite will automatically add leading space, if needed. Use cite.sty's
-% noadjust option (cite.sty V3.8 and later) if you want to turn this off.
-% cite.sty is already installed on most LaTeX systems. Be sure and use
-% version 4.0 (2003-05-27) and later if using hyperref.sty. cite.sty does
-% not currently provide for hyperlinked citations.
-% The latest version can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/cite/
-% The documentation is contained in the cite.sty file itself.
-
-
-
-
-
-
-% *** GRAPHICS RELATED PACKAGES ***
-%
-\ifCLASSINFOpdf
-  % \usepackage[pdftex]{graphicx}
-  % declare the path(s) where your graphic files are
-  % \graphicspath{{../pdf/}{../jpeg/}}
-  % and their extensions so you won't have to specify these with
-  % every instance of \includegraphics
-  % \DeclareGraphicsExtensions{.pdf,.jpeg,.png}
-\else
-  % or other class option (dvipsone, dvipdf, if not using dvips). graphicx
-  % will default to the driver specified in the system graphics.cfg if no
-  % driver is specified.
-  % \usepackage[dvips]{graphicx}
-  % declare the path(s) where your graphic files are
-  % \graphicspath{{../eps/}}
-  % and their extensions so you won't have to specify these with
-  % every instance of \includegraphics
-  % \DeclareGraphicsExtensions{.eps}
-\fi
-% graphicx was written by David Carlisle and Sebastian Rahtz. It is
-% required if you want graphics, photos, etc. graphicx.sty is already
-% installed on most LaTeX systems. The latest version and documentation can
-% be obtained at: 
-% http://www.ctan.org/tex-archive/macros/latex/required/graphics/
-% Another good source of documentation is "Using Imported Graphics in
-% LaTeX2e" by Keith Reckdahl which can be found as epslatex.ps or
-% epslatex.pdf at: http://www.ctan.org/tex-archive/info/
-%
-% latex, and pdflatex in dvi mode, support graphics in encapsulated
-% postscript (.eps) format. pdflatex in pdf mode supports graphics
-% in .pdf, .jpeg, .png and .mps (metapost) formats. Users should ensure
-% that all non-photo figures use a vector format (.eps, .pdf, .mps) and
-% not a bitmapped formats (.jpeg, .png). IEEE frowns on bitmapped formats
-% which can result in "jaggedy"/blurry rendering of lines and letters as
-% well as large increases in file sizes.
-%
-% You can find documentation about the pdfTeX application at:
-% http://www.tug.org/applications/pdftex
-
-
-
-
-
-% *** MATH PACKAGES ***
-%
-%\usepackage[cmex10]{amsmath}
-% A popular package from the American Mathematical Society that provides
-% many useful and powerful commands for dealing with mathematics. If using
-% it, be sure to load this package with the cmex10 option to ensure that
-% only type 1 fonts will utilized at all point sizes. Without this option,
-% it is possible that some math symbols, particularly those within
-% footnotes, will be rendered in bitmap form which will result in a
-% document that can not be IEEE Xplore compliant!
-%
-% Also, note that the amsmath package sets \interdisplaylinepenalty to 10000
-% thus preventing page breaks from occurring within multiline equations. Use:
-%\interdisplaylinepenalty=2500
-% after loading amsmath to restore such page breaks as IEEEtran.cls normally
-% does. amsmath.sty is already installed on most LaTeX systems. The latest
-% version and documentation can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/required/amslatex/math/
-
-
-
-
-
-% *** SPECIALIZED LIST PACKAGES ***
-%
-%\usepackage{algorithmic}
-% algorithmic.sty was written by Peter Williams and Rogerio Brito.
-% This package provides an algorithmic environment fo describing algorithms.
-% You can use the algorithmic environment in-text or within a figure
-% environment to provide for a floating algorithm. Do NOT use the algorithm
-% floating environment provided by algorithm.sty (by the same authors) or
-% algorithm2e.sty (by Christophe Fiorio) as IEEE does not use dedicated
-% algorithm float types and packages that provide these will not provide
-% correct IEEE style captions. The latest version and documentation of
-% algorithmic.sty can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/algorithms/
-% There is also a support site at:
-% http://algorithms.berlios.de/index.html
-% Also of interest may be the (relatively newer and more customizable)
-% algorithmicx.sty package by Szasz Janos:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/algorithmicx/
-
-
-
-
-% *** ALIGNMENT PACKAGES ***
-%
-%\usepackage{array}
-% Frank Mittelbach's and David Carlisle's array.sty patches and improves
-% the standard LaTeX2e array and tabular environments to provide better
-% appearance and additional user controls. As the default LaTeX2e table
-% generation code is lacking to the point of almost being broken with
-% respect to the quality of the end results, all users are strongly
-% advised to use an enhanced (at the very least that provided by array.sty)
-% set of table tools. array.sty is already installed on most systems. The
-% latest version and documentation can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/required/tools/
-
-
-%\usepackage{mdwmath}
-%\usepackage{mdwtab}
-% Also highly recommended is Mark Wooding's extremely powerful MDW tools,
-% especially mdwmath.sty and mdwtab.sty which are used to format equations
-% and tables, respectively. The MDWtools set is already installed on most
-% LaTeX systems. The lastest version and documentation is available at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/mdwtools/
-
-
-% IEEEtran contains the IEEEeqnarray family of commands that can be used to
-% generate multiline equations as well as matrices, tables, etc., of high
-% quality.
-
-
-%\usepackage{eqparbox}
-% Also of notable interest is Scott Pakin's eqparbox package for creating
-% (automatically sized) equal width boxes - aka "natural width parboxes".
-% Available at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/eqparbox/
-
-
-
-
-
-% *** SUBFIGURE PACKAGES ***
-%\usepackage[tight,footnotesize]{subfigure}
-% subfigure.sty was written by Steven Douglas Cochran. This package makes it
-% easy to put subfigures in your figures. e.g., "Figure 1a and 1b". For IEEE
-% work, it is a good idea to load it with the tight package option to reduce
-% the amount of white space around the subfigures. subfigure.sty is already
-% installed on most LaTeX systems. The latest version and documentation can
-% be obtained at:
-% http://www.ctan.org/tex-archive/obsolete/macros/latex/contrib/subfigure/
-% subfigure.sty has been superceeded by subfig.sty.
-
-
-
-%\usepackage[caption=false]{caption}
-%\usepackage[font=footnotesize]{subfig}
-% subfig.sty, also written by Steven Douglas Cochran, is the modern
-% replacement for subfigure.sty. However, subfig.sty requires and
-% automatically loads Axel Sommerfeldt's caption.sty which will override
-% IEEEtran.cls handling of captions and this will result in nonIEEE style
-% figure/table captions. To prevent this problem, be sure and preload
-% caption.sty with its "caption=false" package option. This is will preserve
-% IEEEtran.cls handing of captions. Version 1.3 (2005/06/28) and later 
-% (recommended due to many improvements over 1.2) of subfig.sty supports
-% the caption=false option directly:
-%\usepackage[caption=false,font=footnotesize]{subfig}
-%
-% The latest version and documentation can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/subfig/
-% The latest version and documentation of caption.sty can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/caption/
-
-
-
-
-% *** FLOAT PACKAGES ***
-%
-%\usepackage{fixltx2e}
-% fixltx2e, the successor to the earlier fix2col.sty, was written by
-% Frank Mittelbach and David Carlisle. This package corrects a few problems
-% in the LaTeX2e kernel, the most notable of which is that in current
-% LaTeX2e releases, the ordering of single and double column floats is not
-% guaranteed to be preserved. Thus, an unpatched LaTeX2e can allow a
-% single column figure to be placed prior to an earlier double column
-% figure. The latest version and documentation can be found at:
-% http://www.ctan.org/tex-archive/macros/latex/base/
-
-
-
-%\usepackage{stfloats}
-% stfloats.sty was written by Sigitas Tolusis. This package gives LaTeX2e
-% the ability to do double column floats at the bottom of the page as well
-% as the top. (e.g., "\begin{figure*}[!b]" is not normally possible in
-% LaTeX2e). It also provides a command:
-%\fnbelowfloat
-% to enable the placement of footnotes below bottom floats (the standard
-% LaTeX2e kernel puts them above bottom floats). This is an invasive package
-% which rewrites many portions of the LaTeX2e float routines. It may not work
-% with other packages that modify the LaTeX2e float routines. The latest
-% version and documentation can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/sttools/
-% Documentation is contained in the stfloats.sty comments as well as in the
-% presfull.pdf file. Do not use the stfloats baselinefloat ability as IEEE
-% does not allow \baselineskip to stretch. Authors submitting work to the
-% IEEE should note that IEEE rarely uses double column equations and
-% that authors should try to avoid such use. Do not be tempted to use the
-% cuted.sty or midfloat.sty packages (also by Sigitas Tolusis) as IEEE does
-% not format its papers in such ways.
-
-
-%\ifCLASSOPTIONcaptionsoff
-%  \usepackage[nomarkers]{endfloat}
-% \let\MYoriglatexcaption\caption
-% \renewcommand{\caption}[2][\relax]{\MYoriglatexcaption[#2]{#2}}
-%\fi
-% endfloat.sty was written by James Darrell McCauley and Jeff Goldberg.
-% This package may be useful when used in conjunction with IEEEtran.cls'
-% captionsoff option. Some IEEE journals/societies require that submissions
-% have lists of figures/tables at the end of the paper and that
-% figures/tables without any captions are placed on a page by themselves at
-% the end of the document. If needed, the draftcls IEEEtran class option or
-% \CLASSINPUTbaselinestretch interface can be used to increase the line
-% spacing as well. Be sure and use the nomarkers option of endfloat to
-% prevent endfloat from "marking" where the figures would have been placed
-% in the text. The two hack lines of code above are a slight modification of
-% that suggested by in the endfloat docs (section 8.3.1) to ensure that
-% the full captions always appear in the list of figures/tables - even if
-% the user used the short optional argument of \caption[]{}.
-% IEEE papers do not typically make use of \caption[]'s optional argument,
-% so this should not be an issue. A similar trick can be used to disable
-% captions of packages such as subfig.sty that lack options to turn off
-% the subcaptions:
-% For subfig.sty:
-% \let\MYorigsubfloat\subfloat
-% \renewcommand{\subfloat}[2][\relax]{\MYorigsubfloat[]{#2}}
-% For subfigure.sty:
-% \let\MYorigsubfigure\subfigure
-% \renewcommand{\subfigure}[2][\relax]{\MYorigsubfigure[]{#2}}
-% However, the above trick will not work if both optional arguments of
-% the \subfloat/subfig command are used. Furthermore, there needs to be a
-% description of each subfigure *somewhere* and endfloat does not add
-% subfigure captions to its list of figures. Thus, the best approach is to
-% avoid the use of subfigure captions (many IEEE journals avoid them anyway)
-% and instead reference/explain all the subfigures within the main caption.
-% The latest version of endfloat.sty and its documentation can obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/endfloat/
-%
-% The IEEEtran \ifCLASSOPTIONcaptionsoff conditional can also be used
-% later in the document, say, to conditionally put the References on a 
-% page by themselves.
-
-
-
-
-
-% *** PDF, URL AND HYPERLINK PACKAGES ***
-%
-%\usepackage{url}
-% url.sty was written by Donald Arseneau. It provides better support for
-% handling and breaking URLs. url.sty is already installed on most LaTeX
-% systems. The latest version can be obtained at:
-% http://www.ctan.org/tex-archive/macros/latex/contrib/misc/
-% Read the url.sty source comments for usage information. Basically,
-% \url{my_url_here}.
-
-
-
-
-
-% *** Do not adjust lengths that control margins, column widths, etc. ***
-% *** Do not use packages that alter fonts (such as pslatex).         ***
-% There should be no need to do such things with IEEEtran.cls V1.6 and later.
-% (Unless specifically asked to do so by the journal or conference you plan
-% to submit to, of course. )
-
+\usepackage{subfig}
+\usepackage{color}
+\usepackage{graphicx}
 
 % correct bad hyphenation here
 \hyphenation{op-tical net-works semi-conduc-tor}
 
 % correct bad hyphenation here
 \hyphenation{op-tical net-works semi-conduc-tor}
 % was not built to handle multiple paragraphs
 %
 
 % was not built to handle multiple paragraphs
 %
 
-\author{Jean-Fran\c cois Couchot, Raphael Couturier, and  Christophe Guyeux*}
-
-\IEEEauthorblockA{FEMTO-ST Institute, UMR 6174 CNRS\\
-Computer Science Laboratory DISC\\
-University of Franche-Comt\'{e}\\
-Besan\c con, France\\
-\{jean-francois.couchot,raphael.couturier, christophe.guyeux\}@femto-st.fr}\\
+\author{Jean-Fran\c cois Couchot, Raphael Couturier, and  Christophe Guyeux*
+  FEMTO-ST Institute, UMR 6174 CNRS\\
+  Computer Science Laboratory DISC\\
+  University of Franche-Comt\'{e}\\
+  Besan\c con, France\\
+  \{jean-francois.couchot,raphael.couturier, christophe.guyeux\}@femto-st.fr\\
 * Authors in alphabetic order\\
 }
 * Authors in alphabetic order\\
 }
-
-
-
-% \author{Michael~Shell,~\IEEEmembership{Member,~IEEE,}
-%         John~Doe,~\IEEEmembership{Fellow,~OSA,}
-%         and~Jane~Doe,~\IEEEmembership{Life~Fellow,~IEEE}% <-this % stops a space
-% \thanks{M. Shell is with the Department
-% of Electrical and Computer Engineering, Georgia Institute of Technology, Atlanta,
-% GA, 30332 USA e-mail: (see http://www.michaelshell.org/contact.html).}% <-this % stops a space
-% \thanks{J. Doe and J. Doe are with Anonymous University.}% <-this % stops a space
-% \thanks{Manuscript received April 19, 2005; revised January 11, 2007.}}
-
-% note the % following the last \IEEEmembership and also \thanks - 
-% these prevent an unwanted space from occurring between the last author name
-% and the end of the author line. i.e., if you had this:
-% 
-% \author{....lastname \thanks{...} \thanks{...} }
-%                     ^------------^------------^----Do not want these spaces!
-%
-% a space would be appended to the last name and could cause every name on that
-% line to be shifted left slightly. This is one of those "LaTeX things". For
-% instance, "\textbf{A} \textbf{B}" will typeset as "A B" not "AB". To get
-% "AB" then you have to do: "\textbf{A}\textbf{B}"
-% \thanks is no different in this regard, so shield the last } of each \thanks
-% that ends a line with a % and do not let a space in before the next \thanks.
-% Spaces after \IEEEmembership other than the last one are OK (and needed) as
-% you are supposed to have spaces between the names. For what it is worth,
-% this is a minor point as most people would not even notice if the said evil
-% space somehow managed to creep in.
-
-
-
-% The paper headers
-%\markboth{Journal of \LaTeX\ Class Files,~Vol.~6, No.~1, January~2007}%
-%{Shell \MakeLowercase{\textit{et al.}}: Bare Demo of IEEEtran.cls for Journals}
-% The only time the second header will appear is for the odd numbered pages
-% after the title page when using the twoside option.
-% 
-% *** Note that you probably will NOT want to include the author's ***
-% *** name in the headers of peer review papers.                   ***
-% You can use \ifCLASSOPTIONpeerreview for conditional compilation here if
-% you desire.
-
-
-
-
-% If you want to put a publisher's ID mark on the page you can do it like
-% this:
-%\IEEEpubid{0000--0000/00\$00.00~\copyright~2007 IEEE}
-% Remember, if you use this you must call \IEEEpubidadjcol in the second
-% column for its text to clear the IEEEpubid mark.
-
-
-
-% use for special paper notices
-%\IEEEspecialpapernotice{(Invited Paper)}
-
-
-
-
+\newcommand{\JFC}[1]{\begin{color}{green}\textit{#1}\end{color}}
 % make the title area
 % make the title area
-\maketitle
+%\maketitle
 
 
 \begin{abstract}
 %\boldmath
 The abstract goes here.
 \end{abstract}
 
 
 \begin{abstract}
 %\boldmath
 The abstract goes here.
 \end{abstract}
-% IEEEtran.cls defaults to using nonbold math in the Abstract.
-% This preserves the distinction between vectors and scalars. However,
-% if the journal you are submitting to favors bold math in the abstract,
-% then you can use LaTeX's standard command \boldmath at the very start
-% of the abstract to achieve this. Many IEEE journals frown on math
-% in the abstract anyway.
-
-% Note that keywords are not normally used for peerreview papers.
+
 \begin{IEEEkeywords}
 %IEEEtran, journal, \LaTeX, paper, template.
 Steganography, least-significant-bit (LSB)-based steganography, edge detection, Canny filter, security, syndrome treillis code.
 \begin{IEEEkeywords}
 %IEEEtran, journal, \LaTeX, paper, template.
 Steganography, least-significant-bit (LSB)-based steganography, edge detection, Canny filter, security, syndrome treillis code.
@@ -434,26 +50,18 @@ Steganography, least-significant-bit (LSB)-based steganography, edge detection,
 
 
 
 
 
 
-
-% For peer review papers, you can put extra information on the cover
-% page as needed:
-% \ifCLASSOPTIONpeerreview
-% \begin{center} \bfseries EDICS Category: 3-BBND \end{center}
-% \fi
-%
-% For peerreview papers, this IEEEtran command inserts a page break and
-% creates the second title. It will be ignored for other modes.
 \IEEEpeerreviewmaketitle
 
 
 
 \section{Introduction}
 \IEEEpeerreviewmaketitle
 
 
 
 \section{Introduction}
-
+\input{intro.tex}
 
 \section{Analysis of Steganographic Approaches}
 
 \section{Analysis of Steganographic Approaches}
+\input{analysis.tex}
 
 This work considers digital images as covers and fondation is
 
 This work considers digital images as covers and fondation is
-spatial least_significant-bit (LSB) replacement.
+spatial least significant-bit (LSB) replacement.
 I this data hiding scheme a subset of all the LSB of the cover image is modified 
 with a secret bit stream depending on to a key, the cover, and the message to embed.
 This well studied steganographic approach  never decreases (resp. increases)
 I this data hiding scheme a subset of all the LSB of the cover image is modified 
 with a secret bit stream depending on to a key, the cover, and the message to embed.
 This well studied steganographic approach  never decreases (resp. increases)
@@ -473,15 +81,17 @@ security need : message has to be encrypted before beeing introduced. Using effi
 LSBR: to coarse (apply hugo breaker on it)
 
 \section{Our Approach}
 LSBR: to coarse (apply hugo breaker on it)
 
 \section{Our Approach}
-Image Quality: Edge Image Steganography
+\input{ourapproach.tex}
 
 
-Security aspect:
-BBS-based cprotographic version of the message 
+% Image Quality: Edge Image Steganography
 
 
-Enlarging embeding efficiency:
-Syndrome treillis code  
+% Security aspect:
+% BBS-based cprotographic version of the message 
 
 
+% Enlarging embeding efficiency:
+% Syndrome treillis code  
 
 
+\input{stc.tex}
 \section{Conclusion}
 The conclusion goes here.
 
 \section{Conclusion}
 The conclusion goes here.
 
index 5fc4f7e1f5ef6bea7c7bf32c3b585cd611dfef33..2bf476f6825fa8a647cbcd5749d1a34fedf23daf 100644 (file)
@@ -10,7 +10,8 @@ and inside the extraction one(Fig.~\ref{fig:sch:ext}).
     \subfloat[Data Embedding.]{
       \begin{minipage}{0.49\textwidth}
         \begin{center}
     \subfloat[Data Embedding.]{
       \begin{minipage}{0.49\textwidth}
         \begin{center}
-          \includegraphics[width=5cm]{emb.pdf}
+%          \includegraphics[width=5cm]{emb.pdf}
+          \includegraphics[width=5cm]{emb.ps}
         \end{center}
       \end{minipage}
       \label{fig:sch:emb}
         \end{center}
       \end{minipage}
       \label{fig:sch:emb}
@@ -18,7 +19,8 @@ and inside the extraction one(Fig.~\ref{fig:sch:ext}).
     \subfloat[Data Extraction.]{
       \begin{minipage}{0.49\textwidth}
         \begin{center}
     \subfloat[Data Extraction.]{
       \begin{minipage}{0.49\textwidth}
         \begin{center}
-          \includegraphics[width=5cm]{rec.pdf}
+%          \includegraphics[width=5cm]{rec.pdf}
+          \includegraphics[width=5cm]{rec.ps}
         \end{center}
       \end{minipage}
       \label{fig:sch:ext}
         \end{center}
       \end{minipage}
       \label{fig:sch:ext}
diff --git a/stc/exp/raphus/attaque.py b/stc/exp/raphus/attaque.py
new file mode 100755 (executable)
index 0000000..b3403c4
--- /dev/null
@@ -0,0 +1,213 @@
+#-*- coding:utf-8 -*-
+from os import system
+import Image as Im
+import ImageEnhance
+import PythonMagick as pm
+import numpy as np
+from ConfigParser import ConfigParser
+from random import *
+class Attaque:
+
+    @staticmethod
+    def _commun_in(mat):
+        (l,h)=mat.shape
+        at = Im.new("L",(l,h))
+        at.putdata(mat.flatten())
+        return (l,h,at)
+
+    @staticmethod
+    def _commun_out(at):
+        (l,h)=at.size
+        return np.array(at.getdata()).reshape((l,h))
+    
+
+    @staticmethod
+    def rotation(mat,angle, nombre):
+        (l,h,at) = Attaque._commun_in(mat)
+        for k in range(nombre):
+            carreNoir=Im.new('L',(l*3,h*3),color=1)
+            carreNoir.paste(at,(l+1,h+1))
+            tourne = carreNoir.rotate(angle)
+            carreNoir = tourne.rotate(-angle)
+            carreNoir = carreNoir.crop((l+1,h+1,2*l+1,2*h+1))
+            #carreNoir = carreNoir.crop((l+1,h+1,2*l+1,2*h+1))
+
+        return Attaque._commun_out(carreNoir) 
+        
+
+    @staticmethod
+    def jpeg(mat,nom_temp,taux = 100):
+        '''Attaque par compression jpeg :
+               - taux = 100 : image d'origine,
+               - taux 75 : compression par défaut,
+               - taux = 1 : le plus fort taux de compression.'''
+        (l,h,at) = Attaque._commun_in(mat)        
+        ch = nom_temp+'_'+str(taux)+'.jpg'
+        #TODO : utiliser le module de fichier temporaire de python
+        at.save(ch,quality = taux)
+        at = Im.open(ch)
+        #system('rm '+ch)
+        return Attaque._commun_out(at) 
+        
+
+    @staticmethod
+    def jp2(mat,nom_temp,taux = 100):
+        '''Attaque par compression jpeg :
+               - taux = 100 : image d'origine,
+               - taux 75 : compression par défaut,
+               - taux = 1 : le plus fort taux de compression.'''
+        (l,h,at) = Attaque._commun_in(mat)        
+        at.save("img.bmp")
+        img_2_nm = "img_"+str(taux)+"_.jp2"
+        
+        st = "convert img.bmp -define jp2:rate="+\
+            str(taux/float(100))+" "+img_2_nm
+        print st
+        system(st)
+        system("convert "+img_2_nm+" img_2.png")
+        atb = Im.open("img_2.png")
+        return Attaque._commun_out(atb) 
+
+
+    @staticmethod
+    def decoupage(mat, taille = 50, position = (0,0)):
+        '''
+        Attaque par découpage de l'image.
+        '''
+        (_,_,at) = Attaque._commun_in(mat)        
+        ch = '5007_dec_'+str(taille)+'.png'
+        if taille > 0 :
+            carreNoir=Im.new('L',(taille,taille))
+            carreNoir.putdata([0 for _ in range(taille**2)])
+            at.paste(carreNoir,position)
+#            at.save(ch)
+        return Attaque._commun_out(at) 
+
+
+    @staticmethod
+    def redimensionnement(mat, facteur, nombre = 1):
+        '''
+        Attaque par redimensionnement de l'image. 
+        '''
+        (l,h,at) = Attaque._commun_in(mat)        
+        for k in range(nombre):
+            atb = at.resize((int(l*facteur), int(h*facteur)))
+            atc = atb.resize((l,h))
+        return Attaque._commun_out(atc) 
+
+    @staticmethod
+    def flou(mat,taux = 1):
+
+        '''
+        Attaque en jouant sur le flou/la netteté :
+               - taux = 1 : image d'origine,
+               - taux < 1 : image plus floue,
+               - taux > 1 : image plus nette.
+        '''
+        (_,_,at) = Attaque._commun_in(mat)        
+        ch = '5007_flou_'+str(taux)+'.png'
+        amelioration = ImageEnhance.Sharpness(at)
+        atb = amelioration.enhance(taux)
+#        atb.save(ch)
+        return Attaque._commun_out(atb) 
+
+
+    @staticmethod
+    def contraste(mat,taux = 1):
+        ch = '5007_contrast_'+str(taux)+'.png'
+
+        '''
+        Attaque en jouant sur le flou/la netteté :
+               - taux = 1 : image d'origine,
+               - taux < 1 : image plus contrastée,
+               - taux > 1 : image plus nette.
+        '''
+        (_,_,at) = Attaque._commun_in(mat)        
+        amelioration = ImageEnhance.Contrast(at)
+        atb = amelioration.enhance(taux)
+#        atb.save(ch)
+        return Attaque._commun_out(atb) 
+
+    
+
+
+    @staticmethod
+    def allea_dwt(mat):        
+        """ choisit une des 6 attaques au hasard avec paramètre cohérents au 
+        hasard
+        """
+        nb_at = 6
+        choix = randint(0,5)
+        if choix == 0:
+            return Attaque.rotation(mat,30*random(), 1)
+        if choix == 1:
+            return Attaque.jp2(mat,"alea",int(100*random()))
+        if choix == 2:
+            return Attaque.decoupage(mat, 50, (0,0))
+        if choix == 3:
+            return Attaque.redimensionnement(mat, 0.75*randint(1,2),1)
+        if choix == 4:
+            return Attaque.flou(mat, 0.70+.6*random())
+        if choix == 5:
+            return Attaque.contraste(mat,0.70+.6*random())
+
+    @staticmethod
+    def enfloat(mat):
+        (l,c)=mat.shape
+        r=np.zeros((l,c))
+        for i in range(l):
+            for j in range(c) :
+                r[i][j]=float(mat[i][j])
+        return r
+
+
+    @staticmethod
+    def allea_dct(mat):        
+        """ choisit une des 6 attaques au hasard avec paramètre cohérents au 
+        hasard
+        """
+        r=None
+        nb_at = 6
+        choix = randint(0,6)
+        if choix == 0:
+            r=Attaque.rotation(mat,30*random(), 1)
+        if choix == 1:
+            r=Attaque.jp2(mat,"alea",int(100*random()))
+        if choix == 2:
+            r=Attaque.decoupage(mat, 50, (0,0))
+        if choix == 3:
+            r=Attaque.redimensionnement(mat, 0.75*randint(1,2),1)
+        if choix == 4:
+            r=Attaque.flou(mat, 0.70+.6*random())
+        if choix == 5:
+            r=Attaque.contraste(mat,0.70+.6*random())
+        if choix == 6:
+            r=Attaque.jpeg(mat,"alea",int(100*random()))
+            
+        rp = Attaque.enfloat(r)
+        return rp
+        
+     
+    """
+    def bruitGaussien(self, ecarttype):
+        '''
+        Ajoute un bruit gaussien.
+        '''
+        for x in range(self._image.size[0]):
+            for y in range(self._image.size[1]):
+                self._image.putpixel((x,y),
+                     int(random.normal(self._image.getpixel((x,y)), ecarttype)))
+
+
+    def bruitUniforme(self, ecart):
+        '''
+        Ajoute un bruit uniforme.
+        '''
+        for x in range(self._image.size[0]):
+            for y in range(self._image.size[1]):
+                self._image.putpixel((x,y),
+                                     self._image.getpixel((x,y)) + \
+                                     int(random.uniform(-ecart,ecart)))
+
+
+    """
diff --git a/stc/exp/raphus/attaques.py b/stc/exp/raphus/attaques.py
new file mode 100644 (file)
index 0000000..52fde83
--- /dev/null
@@ -0,0 +1,369 @@
+#-*-coding:utf-8-*-
+
+#############################################
+# Script réalisé dans le cadre du papier
+# concernant l'utilisation de plusieurs
+# fonctions chaotiques (pas seulement la 
+# négation vectorielle) pour le tatouage.
+#
+# On utilise 3 fonctions différentes, on tatoue
+# dans le domaine ondelette.
+#############################################
+import pywt
+
+from numpy import * 
+
+#from outilsBase import conversion, getBit, setBit
+from random import *
+from copy import deepcopy
+import Image as im
+from ImageChops import difference
+from suite import *
+from attaque import Attaque
+
+def matrice_to_bits(matrice):
+    '''
+    Renvoie la matrice des écritures binaires de matrice.
+    Les coefficients floants deviennent des chaînes (str) de bits.
+    '''
+    (m,n) = matrice.shape
+    retour = []
+    for l in range(m):
+        ligne = []
+        for c in range(n):
+            ligne.append(conversion(str(matrice[l,c]),2))
+        retour.append(ligne)
+    return retour
+
+
+
+def matrice_lscs(matrice,lscs):
+    '''
+    Matrice est une liste de listes, lscs est une liste.
+
+    A partir d'une matrice de coefficients binaires, vus comme
+    des chaines de caractères, extrait les bits dont les positions
+    sont données par la liste lscs.
+    
+    Dans la liste lscs, un entier positif signifie devant la virgule,
+    un entier négatif signifie derrière. Le premier bit devant la 
+    virgule est le bit 1, le premier bit derrière la virgule est le -1.
+
+    Le retour est une liste de bits (entiers).
+    '''
+    m,n = len(matrice), len(matrice[0])
+    retour = []
+    for l in range(m):
+        for c in range(n):
+            #num = str(round(float(matrice[l][c]),2))
+            num = matrice[l][c]
+
+            if '.' not in num:
+                ent,dec = num.replace('-',''),'0'
+            else:
+                ent,dec = num.replace('-','').split('.')
+            ent,dec = list(ent),list(dec)
+            ent.reverse()
+            for lsc in lscs:
+                if lsc > 0 and len(ent)>=lsc:
+                    retour.append(ent[lsc-1])
+                elif lsc<0 and len(dec)>=abs(lsc):
+                    retour.append(dec[abs(lsc)-1])
+                else:
+                    retour.append('0')
+    return [int(k) for k in retour][:-3]
+
+
+def embarque(liste,matrice,lscs):
+    m,n = len(matrice), len(matrice[0])
+    retour = []
+    cpt = 0
+    for l in range(m):
+        for c in range(n):
+            if '-' in matrice[l][c]:
+                signe = '-'
+            else:
+                signe = ''
+            if '.' not in matrice[l][c]:
+                ent,dec = matrice[l][c].replace('-',''),'0'
+            else:
+                ent,dec = matrice[l][c].replace('-','').split('.')
+            ent,dec = list(ent),list(dec)
+            ent.reverse()
+            maximum = max([abs(k) for k in lscs])
+            ent = list(''.join(ent).zfill(maximum+2))
+            dec = list(''.join(dec).zfill(maximum+2))
+            print dec
+            for lsc in lscs:
+                if lsc > 0:
+                    ent[lsc-1] = str(liste[cpt])
+                else:
+                    dec[abs(lsc)-1] = str(liste[cpt])
+                cpt += 1
+            ent.reverse()
+            ent = ''.join(ent)
+            dec = ''.join(dec)
+            print ent+'.'+dec
+
+
+
+def f(L):
+    assert len(L)%4 == 1
+    n = len(L)/4
+    retour = [int(not L[k]) for k in range(n)]
+    retour.extend([L[k-n] for k in range(n,2*n)])
+    retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in range(2*n,4*n)])
+    retour.extend([int(not L[2*n])])
+    return retour
+
+
+
+
+def f(L):
+    retour = [int(not L[0])]
+    retour.extend([L[k-1] for k in range(1,len(L))])
+    return retour    
+
+
+
+
+def f(x):
+    rl=[]
+    k = 1
+    for el in x:
+        if k%2 != 0 :
+            rl.append(int(not el))
+        else:
+            rl.append(0 if sum(x[k-2:k])%2==0 else 1 )
+        k+=1
+    return rl
+
+
+
+
+def f(i,x):
+    r = 0
+    if i%2 == 0 :
+        r = int(not x[i])
+    else:
+        r = 0 if sum(x[i-1:i+1])%2==0 else 1 
+    return r
+
+
+
+def f(i,L):
+    return int(not L[i])
+
+
+
+def embarque2(liste,matrice,lscs):
+    
+    m,n = len(matrice), len(matrice[0])
+    retour = deepcopy(matrice)
+    cpt = 0
+    for l in range(m):
+        for c in range(n):
+            for lsc in lscs:
+                try:
+                    retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt])
+                    cpt += 1
+                except:
+                    pass
+    return retour
+
+def PSNR(mat1,mat2):
+    (li,co) = mat1.shape
+    '''
+    Retourne le PSNR entre deux images.
+    '''
+    from math import log
+    densite = 2**8-1
+    eqm = 0
+    for k in range(li):
+        for l in range(co):
+            eqm+=(mat1[k][l] - mat2[k][l])**2
+    r= float(eqm)/li/co
+    if r !=0:
+        return 10*log(densite**2/r,10)
+    else:
+        return "Infini"
+
+
+    
+def diff(mat1,mat2):
+    lm=len(mat1)
+    cpt = 0
+    for k in range(lm):
+        if mat1[k] != mat2[k] :
+            cpt +=1
+            #print mat1[k],mat2[k] 
+    return float(100)*cpt/lm
+
+def arrondi_en_entier(mat):
+    (l,c) = mat.shape
+    return array([[round(mat[i][j]) for j in range(c)]for i in range(l)])
+        
+        
+            
+
+
+def experience(nom_fichier):
+    str_acc = "nom;"+nom_fichier
+
+    initiale_image = im.open(nom_fichier+".png")
+    (taillex,tailley) = initiale_image.size
+    initiale_matrice =  array(initiale_image.getdata()).reshape((taillex,tailley))
+
+    #recup 
+    hote_dct = Dct(nom_fichier+".png",idx_dct)
+    hote_dct2 = Dct(nom_fichier+".png",idx_dct)
+
+    initiale_dct= deepcopy(hote_dct.get_ext_dct())
+    
+
+    # recup bits insignifiants 
+    initiale_lscs = matrice_lscs(matrice_to_bits(initiale_dct),LSCs)
+    initiale_lscs_a_iterer = deepcopy(initiale_lscs)
+
+    # Nb LSCs 
+    lm = len(initiale_lscs)
+    # Itérations D2
+    ciis = CIIS(random(),random(),random()/2,lm-1,lm)._genere()    
+    for k in range(4*lm):
+        strat = ciis.next()
+        #print strat 
+        initiale_lscs_a_iterer[strat] = int(
+            f(strat,initiale_lscs_a_iterer))
+
+
+
+    # Calcul du nombre de différences dans la matrice DCT
+
+
+    str_acc += ";#lscs;" + str(lm)
+
+    
+    dif_iter = diff(initiale_lscs,initiale_lscs_a_iterer)
+    str_acc += ";#diff it ; " + str(dif_iter)
+    
+    
+    # Tatouage de la matrice")
+    marquee_ext_dct = embarque2(initiale_lscs_a_iterer,
+                           initiale_dct,LSCs)    
+    
+    # reconstruction de la matrice complete
+    hote_dct2.set_ext_dct(marquee_ext_dct)
+    marquee_matrice = hote_dct2._matrice
+    marquee_matrice = arrondi_en_entier(marquee_matrice)
+
+    
+    #sauvegarde de l'image
+    (l,h)=marquee_matrice.shape
+    at = im.new("L",(l,h))
+    at.putdata(marquee_matrice.flatten())
+    at.save(nom_fichier+"_bis.png")
+    at.show()
+
+
+#listing = os.listdir(path_cover)
+
+
+
+    # psnr
+    str_acc += ";PSNR;" + str(PSNR(initiale_matrice,marquee_matrice))
+
+    
+    nbexp=10
+    # matrices attaquees par rotation
+    attaquee_matrice = [] 
+    print "rotations"
+    for k in range(nbexp):
+        at  = Attaque.rotation(marquee_matrice,
+                               3*(k+1),
+                               1)
+        attaquee_matrice += [at]
+        
+    # matrices attaquees compression jpeg
+    print "compression"
+    for k in range(nbexp):
+        at  = Attaque.jpeg(marquee_matrice,
+                           nom_fichier,
+                           100-3*(k+1))
+        attaquee_matrice +=  [at]
+                                          
+
+    # matrices attaquees compression jp2000
+    print "compression jp2000"
+    for k in range(nbexp):
+        at  = Attaque.jp2(marquee_matrice,
+                           nom_fichier,
+                           100-10*(k+1))
+        attaquee_matrice +=  [at]
+        
+
+
+    print "decoupage"        
+    # matrices attaquees decoupage
+    for k in range(nbexp):
+        t = int(0.1*(k+1)*min(taillex,tailley))
+        at  = Attaque.decoupage(marquee_matrice,
+                                t,
+                                (0,0))
+        attaquee_matrice +=  [at]
+
+    print "flou"            
+    # matrices attaquees flou
+    for k in range(nbexp):
+        t=0.6+0.08*(k+1)
+        at  = Attaque.flou(marquee_matrice,t)
+        attaquee_matrice +=  [at]
+
+    print "contraste"            
+    # matrices attaquees contrast
+    for k in range(nbexp):
+        t=0.6+0.08*(k+1)
+        at  = Attaque.contraste(marquee_matrice,t)
+        attaquee_matrice +=  [at]
+
+
+    # matrices attaquees redimensionnement
+    print "dimensionnement"
+    attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
+                                                   0.75,
+                                                   1)]
+    attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
+                                                   1.5,
+                                                   1)]
+    
+
+
+
+    print  "nombre d'attaques",len(attaquee_matrice)
+    
+    # evaluation des attaques
+    _,(marquee_H2,marquee_V2,marquee),(_,_,_)  = \
+        pywt.wavedec2(marquee_matrice,
+                      'db1',
+                      level = 2)
+    marquee_lscs = matrice_lscs(matrice_to_bits(marquee_matrice),LSCs)
+
+    c=0
+    for am in attaquee_matrice:
+        c +=1
+        attaquee = am
+        
+        attaquee_lscs = matrice_lscs(matrice_to_bits(attaquee),LSCs)
+        d = diff(marquee_lscs,attaquee_lscs)
+        str_acc += ";" + str(d)
+
+
+
+    return str_acc
+
+    
+"""
+for j in sample(range(1,3001),2):    
+    print experience("../images/"+str(j),3)
+
+"""
+print experience("../images/"+str(3622),3)
diff --git a/stc/exp/raphus/script_attaques.py b/stc/exp/raphus/script_attaques.py
new file mode 100644 (file)
index 0000000..1e7d873
--- /dev/null
@@ -0,0 +1,444 @@
+#-*-coding:utf-8-*-
+
+#############################################
+# Script réalisé dans le cadre du papier
+# concernant l'utilisation de plusieurs
+# fonctions chaotiques (pas seulement la 
+# négation vectorielle) pour le tatouage.
+#
+# On utilise 3 fonctions différentes, on tatoue
+# dans le domaine ondelette.
+#############################################
+
+from numpy import * 
+from sobel555_for_ensemble import *
+from bbs import *
+
+#from outilsBase import conversion, getBit, setBit
+from random import *
+from copy import deepcopy
+import Image as im
+from ImageChops import difference
+from attaque import Attaque
+
+def matrice_to_bits(matrice):
+    '''
+    Renvoie la matrice des écritures binaires de matrice.
+    Les coefficients floants deviennent des chaînes (str) de bits.
+    '''
+    (m,n) = matrice.shape
+    retour = []
+    for l in range(m):
+        ligne = []
+        for c in range(n):
+            ligne.append(conversion(str(matrice[l,c]),2))
+        retour.append(ligne)
+    return retour
+
+
+
+def matrice_lscs(matrice,lscs):
+    '''
+    Matrice est une liste de listes, lscs est une liste.
+
+    A partir d'une matrice de coefficients binaires, vus comme
+    des chaines de caractères, extrait les bits dont les positions
+    sont données par la liste lscs.
+    
+    Dans la liste lscs, un entier positif signifie devant la virgule,
+    un entier négatif signifie derrière. Le premier bit devant la 
+    virgule est le bit 1, le premier bit derrière la virgule est le -1.
+
+    Le retour est une liste de bits (entiers).
+    '''
+    m,n = len(matrice), len(matrice[0])
+    retour = []
+    for l in range(m):
+        for c in range(n):
+            #num = str(round(float(matrice[l][c]),2))
+            num = matrice[l][c]
+
+            if '.' not in num:
+                ent,dec = num.replace('-',''),'0'
+            else:
+                ent,dec = num.replace('-','').split('.')
+            ent,dec = list(ent),list(dec)
+            ent.reverse()
+            for lsc in lscs:
+                if lsc > 0 and len(ent)>=lsc:
+                    retour.append(ent[lsc-1])
+                elif lsc<0 and len(dec)>=abs(lsc):
+                    retour.append(dec[abs(lsc)-1])
+                else:
+                    retour.append('0')
+    return [int(k) for k in retour][:-3]
+
+
+def embarque(liste,matrice,lscs):
+    m,n = len(matrice), len(matrice[0])
+    retour = []
+    cpt = 0
+    for l in range(m):
+        for c in range(n):
+            if '-' in matrice[l][c]:
+                signe = '-'
+            else:
+                signe = ''
+            if '.' not in matrice[l][c]:
+                ent,dec = matrice[l][c].replace('-',''),'0'
+            else:
+                ent,dec = matrice[l][c].replace('-','').split('.')
+            ent,dec = list(ent),list(dec)
+            ent.reverse()
+            maximum = max([abs(k) for k in lscs])
+            ent = list(''.join(ent).zfill(maximum+2))
+            dec = list(''.join(dec).zfill(maximum+2))
+            print dec
+            for lsc in lscs:
+                if lsc > 0:
+                    ent[lsc-1] = str(liste[cpt])
+                else:
+                    dec[abs(lsc)-1] = str(liste[cpt])
+                cpt += 1
+            ent.reverse()
+            ent = ''.join(ent)
+            dec = ''.join(dec)
+            print ent+'.'+dec
+
+
+
+def f(L):
+    assert len(L)%4 == 1
+    n = len(L)/4
+    retour = [int(not L[k]) for k in range(n)]
+    retour.extend([L[k-n] for k in range(n,2*n)])
+    retour.extend([int(L[k-2*n])*int(not L[k+1]) for k in range(2*n,4*n)])
+    retour.extend([int(not L[2*n])])
+    return retour
+
+
+
+
+def f(L):
+    retour = [int(not L[0])]
+    retour.extend([L[k-1] for k in range(1,len(L))])
+    return retour    
+
+
+
+
+def f(x):
+    rl=[]
+    k = 1
+    for el in x:
+        if k%2 != 0 :
+            rl.append(int(not el))
+        else:
+            rl.append(0 if sum(x[k-2:k])%2==0 else 1 )
+        k+=1
+    return rl
+
+
+
+
+def f(i,x):
+    r = 0
+    if i%2 == 0 :
+        r = int(not x[i])
+    else:
+        r = 0 if sum(x[i-1:i+1])%2==0 else 1 
+    return r
+
+
+
+def f(i,L):
+    return int(not L[i])
+
+
+
+def embarque2(liste,matrice,lscs):
+    
+    m,n = len(matrice), len(matrice[0])
+    retour = deepcopy(matrice)
+    cpt = 0
+    for l in range(m):
+        for c in range(n):
+            for lsc in lscs:
+                try:
+                    retour[l,c] = setBit(str(retour[l,c]),lsc, liste[cpt])
+                    cpt += 1
+                except:
+                    pass
+    return retour
+
+def PSNR(mat1,mat2):
+    (li,co) = mat1.shape
+    '''
+    Retourne le PSNR entre deux images.
+    '''
+    from math import log
+    densite = 2**8-1
+    eqm = 0
+    for k in range(li):
+        for l in range(co):
+            eqm+=(mat1[k][l] - mat2[k][l])**2
+    r= float(eqm)/li/co
+    if r !=0:
+        return 10*log(densite**2/r,10)
+    else:
+        return "Infini"
+
+
+    
+def diff(mat1,mat2):
+    lm=len(mat1)
+    cpt = 0
+    for k in range(lm):
+        if mat1[k] != mat2[k] :
+            cpt +=1
+            #print mat1[k],mat2[k] 
+    return float(100)*cpt/lm
+
+def arrondi_en_entier(mat):
+    (l,c) = mat.shape
+    return array([[round(mat[i][j]) for j in range(c)]for i in range(l)])
+        
+        
+
+
+def sauve(data,outfile="dummy.png",file_msg="invader.png"):
+    (l,h)=im.open(file_msg).size
+    outIm = im.new('L',im.open(file_msg).size)
+    queue = [255 if x != 0 else 0 for x in data]
+    queue = queue[len(queue)-l*h:]
+    outIm.putdata(queue)
+    outIm.save("apresattaque.png")
+
+            
+
+def retrouve_message_parametre(file_msg="invader.png"):
+    
+    bbs = BlumBlumShub();
+    bbs.setN(M)
+    bbs.setSeed(X)
+
+    message = []
+    for c in [x if x==0 else 1 for x in im.open(file_msg).getdata()]:
+        message +=[c]
+    
+    leng_msg=len(message)
+    leng='%08d'%len(message)
+    len_leng=len(leng)
+    leng_error=int(len_leng)
+    leng_cor=leng    
+    List_pack=a2b_list(leng_cor)
+    List_pack += message
+    #print List_pack
+    leng_msg=len(List_pack)
+
+    List_random=[]
+    while len(List_random)<leng_msg:
+        List_random.extend(Denary2Binary(bbs.next()))
+
+
+    Message=[(int(List_pack[l])^int(List_random[l])) for l in xrange(len(List_pack))]
+    return (leng_msg,Message,List_random)
+
+                            
+
+
+
+def experience(nom_fichier,leng_msg,Message,List_random):
+#    print "message initial",Message
+    bit_to_read = 1
+    dd = im.open(nom_fichier)
+    dd = dd.convert('RGB') 
+    red, green, blue = dd.split()
+    level=red.copy()
+    at = level
+    (l,h)=red.size
+    marquee_matrice = np.array(at.getdata()).reshape((l,h))
+    level= array(level.getdata()).flatten()
+
+
+    ############# construire ici les attaques
+    nbexp=1
+    # matrices attaquees par rotation
+    attaquee_matrice = [] 
+    print "rotations"
+    for k in range(nbexp):
+        at  = Attaque.rotation(marquee_matrice,
+                               90,
+                               1)
+
+        m = [((abs(marquee_matrice-at)[i,j]),(i,j)) for i in xrange(l) for j in xrange(h)]
+      
+        #m =  sorted(m.items(), key=itemgetter(0))
+
+        print "diffence max", m
+        
+        attaquee_matrice += [at]
+
+    """
+
+    # matrices attaquees compression jpeg
+    print "compression"
+    for k in range(nbexp):
+        at  = Attaque.jpeg(marquee_matrice,
+                           nom_fichier,
+                           100-3*(k+1))
+        attaquee_matrice +=  [at]
+                                          
+    
+    # matrices attaquees compression jp2000
+    print "compression jp2000"
+    for k in range(nbexp):
+        at  = Attaque.jp2(marquee_matrice,
+                           nom_fichier,
+                           100-10*(k+1))
+        attaquee_matrice +=  [at]
+        
+
+
+    print "decoupage"        
+    # matrices attaquees decoupage
+    for k in range(nbexp):
+        t = int(0.1*(k+1)*min(taillex,tailley))
+        at  = Attaque.decoupage(marquee_matrice,
+                                t,
+                                (0,0))
+        attaquee_matrice +=  [at]
+
+    print "flou"            
+    # matrices attaquees flou
+    for k in range(nbexp):
+        t=0.6+0.08*(k+1)
+        at  = Attaque.flou(marquee_matrice,t)
+        attaquee_matrice +=  [at]
+        
+    print "contraste"            
+    # matrices attaquees contrast
+    for k in range(nbexp):
+        t=0.9#0.6+0.08*(k+1)
+        at  = Attaque.contraste(marquee_matrice,t)
+        attaquee_matrice +=  [at]
+
+    
+    # matrices attaquees redimensionnement
+    print "dimensionnement"
+    attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
+                                                   0.75,
+                                                   1)]
+    attaquee_matrice += [Attaque.redimensionnement(marquee_matrice,
+                                                   1.5,
+                                                   1)]
+    
+
+                                                   
+    """                                                   
+                                                   
+    print  "nombre d'attaques",len(attaquee_matrice)
+
+
+
+    c=0
+    for am in attaquee_matrice:
+        c +=1
+        attaquee = am        
+        im2 = im.new('L',dd.size)
+        im2.putdata(attaquee.flatten())
+        im2.save("apresRot.png")
+
+
+
+
+
+
+        #attaquee.copy()
+        print         im2,dd,leng_msg
+        [List_bit_to_change2,Weight2]=compute_filter_canny(im2,dd,leng_msg)
+        # on a mis dd et leng_msg : c'est juste pour la taille.
+        #level2= array(level.getdata()).flatten()
+
+        level2= array(im2.getdata()).flatten()
+
+        print "support2",len(List_bit_to_change2)
+        print "weight2",len(Weight2)
+
+        alpha = float(len(List_bit_to_change2))/len(Message)
+        assert alpha >= 2 
+        index = min(int(alpha),9)
+        H_hat2 = {
+        2 : [71,109],
+        3 : [95, 101, 121],
+        4 : [81, 95, 107, 121],
+        5 : [75, 95, 97, 105, 117],
+        6 : [73, 83, 95, 103, 109, 123],
+        7 : [69, 77, 93, 107, 111, 115, 121],
+        8 : [69, 79, 81, 89, 93, 99, 107, 119],
+        9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
+        }[index]
+
+
+
+        Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2]
+        LL2=list(List_bit_to_change2)
+
+        print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))])
+        #print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message2))])
+        #print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))])
+
+        Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)] 
+
+        print "Message final",Message2
+        #print equiv(Message,Message2)
+
+        #print "fini"
+
+        l=0
+        val_mod2=0
+        list_msg=[]
+        decoded_msg=""
+        
+        MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))]
+#    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))
+#    print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])))
+
+        #print "MessageDecoded2",MessageDecoded2
+        #print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))]))
+
+    sauve(MessageDecoded2)
+
+    return MessageDecoded2
+
+
+
+
+
+
+def main(): 
+    path_stego = '/home/couchot/rech/CCG12/canny/stc/exp/raphus/stego/'
+    path_cover = '/home/couchot/rech/BCG10/Oxford11/experiments/images/'
+    list_nb_bit=[]
+    l=0
+    listing = [957, 108, 106, 29, 431, 924, 262, 477, 346, 809]
+    listing = [809]
+    (leng_msg,Message,List_random) = retrouve_message_parametre()
+    print "params :", leng_msg,len(Message),List_random[0:5]
+    for infile in listing:
+        #    if l<10:
+        fi = path_cover+str(infile)+'.png'
+        fo = path_stego+str(infile)+'.png'
+        experience(fo,leng_msg,Message,List_random)
+        l+=1
+
+if __name__ == "__main__":
+    main()
+
+
+
+
+
+
index 89e0cbdd39d07aa7bc39d413c1ce4004607af201..4a31c2028160f9a1e05988c90a399b7a56c26309 100644 (file)
@@ -429,7 +429,7 @@ def compute_filter_canny(level,image,MsgLen):
     processed= array(processed.getdata()).flatten()
     List7=set(compute_list_bit_to_change(100,processed))
 
     processed= array(processed.getdata()).flatten()
     List7=set(compute_list_bit_to_change(100,processed))
 
-    #nb_bit_embedded=(512*512/10)+40
+    
     nb_bit_embedded=max(2*MsgLen,int(len(List3)/MsgLen)*MsgLen)
     print "nb_bit_embedded",nb_bit_embedded
     AvailablePixel3=List3
     nb_bit_embedded=max(2*MsgLen,int(len(List3)/MsgLen)*MsgLen)
     print "nb_bit_embedded",nb_bit_embedded
     AvailablePixel3=List3
@@ -458,9 +458,9 @@ def compute_filter_canny(level,image,MsgLen):
         sub = range(len(level2))
 
 
         sub = range(len(level2))
 
 
-    #print "avail P3",len(AvailablePixel3)
-    #print "avail P5",len(AvailablePixel5)
-    #print "avail P7",len(AvailablePixel7)
+    print "avail P3",len(AvailablePixel3)
+    print "avail P5",len(AvailablePixel5)
+    print "avail P7",len(AvailablePixel7)
 
 
     Weight=[0 for _ in sub]
 
 
     Weight=[0 for _ in sub]
@@ -489,10 +489,115 @@ def compute_filter_canny(level,image,MsgLen):
 
 
 
 
 
 
+def verifie(fileout,leng_msg,Message,):
+    global M,X
+    bit_to_read = 1
+    dd2 = im.open(fileout)
+    dd2 = dd2.convert('RGB') 
+    red2, green, blue = dd2.split()
+    level2=red2.copy()
+
+    [List_bit_to_change2,Weight2]=compute_filter_canny(level2,dd2,leng_msg)
+
+
+    level2= array(level2.getdata()).flatten()
+
+    print "support2",len(List_bit_to_change2)
+    print "message2",len(Message)
+    print "weight2",len(Weight2)
+
+    alpha = float(len(List_bit_to_change2))/len(Message)
+    assert alpha >= 2 
+    index = min(int(alpha),9)
+    H_hat2 = {
+        2 : [71,109],
+        3 : [95, 101, 121],
+        4 : [81, 95, 107, 121],
+        5 : [75, 95, 97, 105, 117],
+        6 : [73, 83, 95, 103, 109, 123],
+        7 : [69, 77, 93, 107, 111, 115, 121],
+        8 : [69, 79, 81, 89, 93, 99, 107, 119],
+        9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
+        }[index]
+
+
+    print H_hat2
 
 
 
 
+    Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2]
+    LL2=list(List_bit_to_change2)
 
 
-def mystego(filein, fileout):
+    """
+    print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))])
+    print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))])
+    print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))])
+    """
+    Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)] 
+    level2=Message2
+
+#    print "mesg",Message
+#    print "mesg2",Message2
+
+    l=0
+    val_mod2=0
+    list_msg=[]
+    decoded_msg=""
+
+
+
+    bbs = BlumBlumShub();
+    bbs.setN(M)
+    bbs.setSeed(X)
+
+    List_random=[]
+    while len(List_random)<len(Message2):
+        List_random.extend(Denary2Binary(bbs.next()))
+
+
+
+    MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))]
+#    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))
+#    print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])))
+
+    #print "MessageDecoded2",MessageDecoded2
+    
+    outIm = im.new("L",im.open("invader.png").size)
+    (l,h) = outIm.size
+    print "taille de l'image",l*h
+    print "taille des donneées",len(MessageDecoded2)
+    queue = [255 if x != 0 else 0 for x in MessageDecoded2]
+    queue = queue[len(queue)-l*h:]
+    outIm.putdata(queue)
+    outIm.save("apresSobel.png")
+"""
+    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))]))
+   for l in List_bit_to_change2:
+       if(val_mod2<leng_error*8):
+           list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
+           if(val_mod2==leng_error*8-1):
+               bin_leng2=''.join(list_msg)
+               coded_msg2=conv_list_bit(bin_leng2)
+               clear_msg2=coded_msg2
+               length_msg=int(clear_msg2)
+               list_msg=[]
+       if(val_mod2>=leng_error*8 and val_mod2<leng_error*8+length_msg*leng_error):
+           list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
+           if(len(list_msg)==leng_error*8):
+               pack=''.join(list_msg)
+               msg=conv_list_bit(pack)
+               decoded_msg=decoded_msg+msg
+               list_msg=[]
+       val_mod2+=1
+       l=l+1
+       print decoded_msg#[0:20]
+"""
+
+
+
+
+
+def mystego(filein, fileout,file_msg="invader"):
     bit_to_read = 1
     global M,X
     bbs = BlumBlumShub();
     bit_to_read = 1
     global M,X
     bbs = BlumBlumShub();
@@ -503,6 +608,8 @@ def mystego(filein, fileout):
     dd = dd.convert('RGB') 
     red, green, blue = dd.split()
     level=red.copy()
     dd = dd.convert('RGB') 
     red, green, blue = dd.split()
     level=red.copy()
+    
+    #print type(level),level
 
 
     """
 
 
     """
@@ -537,7 +644,7 @@ def mystego(filein, fileout):
     """    
 
 
     """    
 
 
-
+    
     message = []
     for c in [x if x==0 else 1 for x in im.open("invader.png").getdata()]:
         message +=[c]
     message = []
     for c in [x if x==0 else 1 for x in im.open("invader.png").getdata()]:
         message +=[c]
@@ -552,15 +659,16 @@ def mystego(filein, fileout):
     #print List_pack
 
     leng_msg=len(List_pack)
     #print List_pack
 
     leng_msg=len(List_pack)
+    print "leng_msg",leng_msg
 
     [List_bit_to_change,Weight]=compute_filter_canny(level,dd,leng_msg)
     level= array(level.getdata()).flatten()
    
     List_random=[]
 
     [List_bit_to_change,Weight]=compute_filter_canny(level,dd,leng_msg)
     level= array(level.getdata()).flatten()
    
     List_random=[]
-    while len(List_random)<len(List_bit_to_change):
+    while len(List_random)<len(List_pack):
         List_random.extend(Denary2Binary(bbs.next()))
 
         List_random.extend(Denary2Binary(bbs.next()))
 
-        
+
 
     #print List_bit_to_change
     Support=[]
 
     #print List_bit_to_change
     Support=[]
@@ -573,11 +681,16 @@ def mystego(filein, fileout):
     Message=[(int(List_pack[l])^int(List_random[l])) for l in xrange(len(List_pack))]
 
     #print "support",len(List_bit_to_change)
     Message=[(int(List_pack[l])^int(List_random[l])) for l in xrange(len(List_pack))]
 
     #print "support",len(List_bit_to_change)
-    #print "message",len(Message)
+    #print "message",Message
     #print "weight",len(Weight)
 
     #print "weight",len(Weight)
 
+    #(x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
+    
     (x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
 
     (x_b,Stc_message,H_hat) = stc(Support,Weight,Message)
 
+    print "comparaison entre stc_message et message", len(Stc_message),len(Message)
+
+
     #print "pourcentage modif",nbdif(x_b,Stc_message)
     #print "taille Stc_message",len(Stc_message)
 #    Stc_message=Message
     #print "pourcentage modif",nbdif(x_b,Stc_message)
     #print "taille Stc_message",len(Stc_message)
 #    Stc_message=Message
@@ -609,129 +722,25 @@ def mystego(filein, fileout):
     zz3.save(fileout)
     #zz4.show()
 
     zz3.save(fileout)
     #zz4.show()
 
+    verifie(fileout,leng_msg,Message)
 
 
-    """
-    
-    dd2 = im.open(fileout)
-    dd2 = dd2.convert('RGB') 
-    red2, green, blue = dd2.split()
-    level2=red2.copy()
-
-    [List_bit_to_change2,Weight2]=compute_filter_canny(level2,dd2,leng_msg)
-
-
-    level2= array(level2.getdata()).flatten()
-
-    print "support2",len(List_bit_to_change2)
-    print "message2",len(Message)
-    print "weight2",len(Weight2)
-
-    alpha = float(len(List_bit_to_change2))/len(Message)
-    assert alpha >= 2 
-    index = min(int(alpha),9)
-    H_hat2 = {
-        2 : [71,109],
-        3 : [95, 101, 121],
-        4 : [81, 95, 107, 121],
-        5 : [75, 95, 97, 105, 117],
-        6 : [73, 83, 95, 103, 109, 123],
-        7 : [69, 77, 93, 107, 111, 115, 121],
-        8 : [69, 79, 81, 89, 93, 99, 107, 119],
-        9 : [69, 79, 81, 89, 93, 99, 107, 119, 125]
-        }[index]
-
-
-    print H_hat,H_hat2
-
-
-    Stc_message2=[getBit(level2[l],bit_to_read) for l in List_bit_to_change2]
-    LL1=list(List_bit_to_change);
-    LL2=list(List_bit_to_change2)
-
-    print "Level",max([level2[l]-level[l] for l in xrange(len(Stc_message2))])
-    print "List bit to change",max([LL2[l]-LL1[l] for l in xrange(len(Stc_message))])
-    print "Stc message", max([Stc_message[l]-Stc_message2[l] for l in xrange(len(Stc_message))])
-
-    Message2 = [x%2 for x in prod(H_hat2,len(Message),Stc_message2)] 
-    level2=Message2
-
-#    print "mesg",Message
-#    print "mesg2",Message2
-
-    print equiv(Message,Message2)
 
 
-    print "fini"
-
-    l=0
-    val_mod2=0
-    list_msg=[]
-    decoded_msg=""
-
-    MessageDecoded2=[(int(Message2[l])^int(List_random[l])) for l in xrange(len(Message2))]
-#    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)]))
-#    print int(conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(leng_error*8)])))
-
-    print "MessageDecoded2",MessageDecoded2
-    print conv_list_bit(''.join([`MessageDecoded2[i]` for i in xrange(len(Message2))]))
-
-
-    
-
-
-#    for l in List_bit_to_change2:
-#        if(val_mod2<leng_error*8):
-#            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
-#            if(val_mod2==leng_error*8-1):
-#                bin_leng2=''.join(list_msg)
-#                coded_msg2=conv_list_bit(bin_leng2)
-#                clear_msg2=coded_msg2
-#                length_msg=int(clear_msg2)
-#                list_msg=[]
-#        if(val_mod2>=leng_error*8 and val_mod2<leng_error*8+length_msg*leng_error):
-#            list_msg.append(`getBit(level2[l],bit_to_read)^int(List_random[val_mod2])`)
-#            if(len(list_msg)==leng_error*8):
-#                pack=''.join(list_msg)
-#                msg=conv_list_bit(pack)
-#                decoded_msg=decoded_msg+msg
-#                list_msg=[]
-#        val_mod2+=1
-#        l=l+1
-
-    print decoded_msg#[0:20]
-    print len(List_bit_to_change)
-    list_nb_bit.append(filein)
-    list_nb_bit.append(len(List_bit_to_change2))
-
-"""
-
-
-#path_cover = '/localhome/couturie/ensemble/cover_bad_laplace/'
-path_stego = '/home/couchot/rech/CCG12/canny/stc/exp/raphus/stego/'
-path_cover = '/home/couchot/rech/BCG10/Oxford11/experiments/images/'
-#path_stego = '/tmp/'
-#path_stego = '/home/couturie/BossBase-1.0-canny/'
-#listing = os.listdir(path_cover)
-
-
-list_nb_bit=[]
-l=0
 
 
 
 # entree sortie 
 
 
 
 # entree sortie 
+def main(): 
+    path_stego = '/home/couchot/rech/CCG12/canny/stc/exp/raphus/stego/'
+    path_cover = '/home/couchot/rech/BCG10/Oxford11/experiments/images/'
+    list_nb_bit=[]
+    l=0
+    listing = [957, 108, 106, 29, 431, 924, 262, 477, 346, 809]
+    for infile in listing:
+        #    if l<10:
+        fi = path_cover+str(infile)+'.png'
+        fo = path_stego+str(infile)+'.png'
+        mystego(fi,fo)
+        l+=1
 
 
-
-listing = [957, 108, 106, 29, 431, 924, 262, 477, 346, 809]
-
-for infile in listing:
-#    if l<10:
-    fi = path_cover+str(infile)+'.png'
-    fo = path_stego+str(infile)+'.png'
-    mystego(fi,fo)
-    l+=1
-
-#f = open('histogram_boss_canny_100255', 'w')
-#f = open('histogram', 'w')
-#for item in list_nb_bit:
-#f.write("%s\n" % item)
+if __name__ == "__main__":
+    main()
index f940cf950b63e60c9107efc4b63f28412a84ec33..07a5bc6b1d986a011ddd38251edfb65b054b252e 100644 (file)
Binary files a/stc/exp/raphus/stego/106.png and b/stc/exp/raphus/stego/106.png differ
index a25b8a007911e9b086938100eec150a57ca7a855..658d5a6af2388d621ae97967c807ce75f1f49d8c 100644 (file)
Binary files a/stc/exp/raphus/stego/108.png and b/stc/exp/raphus/stego/108.png differ
index 0afaf53bcd56b92426150c9432b44b849cd37d48..ee013e12c636aa06c26dc46808df57a5ed1dd2e9 100644 (file)
Binary files a/stc/exp/raphus/stego/262.png and b/stc/exp/raphus/stego/262.png differ
index ad4908f50966094e01e2c21d3ccb5371537bc3dd..2bdb0ef160c4906f6371a80a6bc02704160930be 100644 (file)
Binary files a/stc/exp/raphus/stego/29.png and b/stc/exp/raphus/stego/29.png differ
index 294b8c9ff76361a46aa12a940c973288abe83c37..aa6db90df7ae1d40800f2bbc3dc15d07ead64f1f 100644 (file)
Binary files a/stc/exp/raphus/stego/346.png and b/stc/exp/raphus/stego/346.png differ
index 2f9e749caea25c1d8657bb026eb9a555b272238a..a1bc1ebd8231187bee46f193d107bd85d7b056a4 100644 (file)
Binary files a/stc/exp/raphus/stego/431.png and b/stc/exp/raphus/stego/431.png differ
index dfcd14f7988d7b42f7c1487a31054b8f1104afda..f12dfc5d82263ea22b6fecce53410d4108a1dbb9 100644 (file)
Binary files a/stc/exp/raphus/stego/477.png and b/stc/exp/raphus/stego/477.png differ
index c389151bb12d49c26ff2f2dbda68a714b859e722..9d51f975b742b066677d36dd327a43f84b6533e2 100644 (file)
Binary files a/stc/exp/raphus/stego/809.png and b/stc/exp/raphus/stego/809.png differ
index e04aeabf1b40b56254a2c215dd476b2fe35a27dd..758cfa80956b18cf48b53f0557188bea816383cb 100644 (file)
Binary files a/stc/exp/raphus/stego/924.png and b/stc/exp/raphus/stego/924.png differ
index 1e2585314093616fa9620d4ad97103371fd1509c..9fda4db309ab8b98cddd3e0d020b0822d7d101c4 100644 (file)
Binary files a/stc/exp/raphus/stego/957.png and b/stc/exp/raphus/stego/957.png differ