stc/exp/raphus/attaque.py

   1 #-*- coding:utf-8 -*-
   2 from os import system
   3 import Image as Im
   4 import ImageEnhance
   5 import PythonMagick as pm
   6 import numpy as np
   7 from ConfigParser import ConfigParser
   8 from random import *
   9 class Attaque:
  10
  11     @staticmethod
  12     def _commun_in(mat):
  13         (l,h)=mat.shape
  14         at = Im.new("L",(l,h))
  15         at.putdata(mat.flatten())
  16         return (l,h,at)
  17
  18     @staticmethod
  19     def _commun_out(at):
  20         (l,h)=at.size
  21         return np.array(at.getdata()).reshape((l,h))
  22
  23
  24     @staticmethod
  25     def rotation(mat,angle, nombre):
  26         (l,h,at) = Attaque._commun_in(mat)
  27         for k in range(nombre):
  28             carreNoir=Im.new('L',(l*3,h*3),color=1)
  29             carreNoir.paste(at,(l+1,h+1))
  30             tourne = carreNoir.rotate(angle)
  31             carreNoir = tourne.rotate(-angle)
  32             carreNoir = carreNoir.crop((l+1,h+1,2*l+1,2*h+1))
  33             #carreNoir = carreNoir.crop((l+1,h+1,2*l+1,2*h+1))
  34
  35         return Attaque._commun_out(carreNoir)
  36
  37
  38     @staticmethod
  39     def jpeg(mat,nom_temp,taux = 100):
  40         '''Attaque par compression jpeg :
  41                - taux = 100 : image d'origine,
  42                - taux 75 : compression par défaut,
  43                - taux = 1 : le plus fort taux de compression.'''
  44         (l,h,at) = Attaque._commun_in(mat)
  45         ch = nom_temp+'_'+str(taux)+'.jpg'
  46         #TODO : utiliser le module de fichier temporaire de python
  47         at.save(ch,quality = taux)
  48         at = Im.open(ch)
  49         #system('rm '+ch)
  50         return Attaque._commun_out(at)
  51
  52
  53     @staticmethod
  54     def jp2(mat,nom_temp,taux = 100):
  55         '''Attaque par compression jpeg :
  56                - taux = 100 : image d'origine,
  57                - taux 75 : compression par défaut,
  58                - taux = 1 : le plus fort taux de compression.'''
  59         (l,h,at) = Attaque._commun_in(mat)
  60         at.save("img.bmp")
  61         img_2_nm = "img_"+str(taux)+"_.jp2"
  62
  63         st = "convert img.bmp -define jp2:rate="+\
  64             str(taux/float(100))+" "+img_2_nm
  65         print st
  66         system(st)
  67         system("convert "+img_2_nm+" img_2.png")
  68         atb = Im.open("img_2.png")
  69         return Attaque._commun_out(atb)
  70
  71
  72     @staticmethod
  73     def decoupage(mat, taille = 50, position = (0,0)):
  74         '''
  75         Attaque par découpage de l'image.
  76         '''
  77         (_,_,at) = Attaque._commun_in(mat)
  78         ch = '5007_dec_'+str(taille)+'.png'
  79         if taille > 0 :
  80             carreNoir=Im.new('L',(taille,taille))
  81             carreNoir.putdata([0 for _ in range(taille**2)])
  82             at.paste(carreNoir,position)
  83 #            at.save(ch)
  84         return Attaque._commun_out(at)
  85
  86
  87     @staticmethod
  88     def redimensionnement(mat, facteur, nombre = 1):
  89         '''
  90         Attaque par redimensionnement de l'image.
  91         '''
  92         (l,h,at) = Attaque._commun_in(mat)
  93         for k in range(nombre):
  94             atb = at.resize((int(l*facteur), int(h*facteur)))
  95             atc = atb.resize((l,h))
  96         return Attaque._commun_out(atc)
  97
  98     @staticmethod
  99     def flou(mat,taux = 1):
 100
 101         '''
 102         Attaque en jouant sur le flou/la netteté :
 103                - taux = 1 : image d'origine,
 104                - taux < 1 : image plus floue,
 105                - taux > 1 : image plus nette.
 106         '''
 107         (_,_,at) = Attaque._commun_in(mat)
 108         ch = '5007_flou_'+str(taux)+'.png'
 109         amelioration = ImageEnhance.Sharpness(at)
 110         atb = amelioration.enhance(taux)
 111 #        atb.save(ch)
 112         return Attaque._commun_out(atb)
 113
 114
 115     @staticmethod
 116     def contraste(mat,taux = 1):
 117         ch = '5007_contrast_'+str(taux)+'.png'
 118
 119         '''
 120         Attaque en jouant sur le flou/la netteté :
 121                - taux = 1 : image d'origine,
 122                - taux < 1 : image plus contrastée,
 123                - taux > 1 : image plus nette.
 124         '''
 125         (_,_,at) = Attaque._commun_in(mat)
 126         amelioration = ImageEnhance.Contrast(at)
 127         atb = amelioration.enhance(taux)
 128 #        atb.save(ch)
 129         return Attaque._commun_out(atb)
 130
 131
 132
 133
 134     @staticmethod
 135     def allea_dwt(mat):
 136         """ choisit une des 6 attaques au hasard avec paramètre cohérents au
 137         hasard
 138         """
 139         nb_at = 6
 140         choix = randint(0,5)
 141         if choix == 0:
 142             return Attaque.rotation(mat,30*random(), 1)
 143         if choix == 1:
 144             return Attaque.jp2(mat,"alea",int(100*random()))
 145         if choix == 2:
 146             return Attaque.decoupage(mat, 50, (0,0))
 147         if choix == 3:
 148             return Attaque.redimensionnement(mat, 0.75*randint(1,2),1)
 149         if choix == 4:
 150             return Attaque.flou(mat, 0.70+.6*random())
 151         if choix == 5:
 152             return Attaque.contraste(mat,0.70+.6*random())
 153
 154     @staticmethod
 155     def enfloat(mat):
 156         (l,c)=mat.shape
 157         r=np.zeros((l,c))
 158         for i in range(l):
 159             for j in range(c) :
 160                 r[i][j]=float(mat[i][j])
 161         return r
 162
 163
 164     @staticmethod
 165     def allea_dct(mat):
 166         """ choisit une des 6 attaques au hasard avec paramètre cohérents au
 167         hasard
 168         """
 169         r=None
 170         nb_at = 6
 171         choix = randint(0,6)
 172         if choix == 0:
 173             r=Attaque.rotation(mat,30*random(), 1)
 174         if choix == 1:
 175             r=Attaque.jp2(mat,"alea",int(100*random()))
 176         if choix == 2:
 177             r=Attaque.decoupage(mat, 50, (0,0))
 178         if choix == 3:
 179             r=Attaque.redimensionnement(mat, 0.75*randint(1,2),1)
 180         if choix == 4:
 181             r=Attaque.flou(mat, 0.70+.6*random())
 182         if choix == 5:
 183             r=Attaque.contraste(mat,0.70+.6*random())
 184         if choix == 6:
 185             r=Attaque.jpeg(mat,"alea",int(100*random()))
 186
 187         rp = Attaque.enfloat(r)
 188         return rp
 189
 190
 191     """
 192     def bruitGaussien(self, ecarttype):
 193         '''
 194         Ajoute un bruit gaussien.
 195         '''
 196         for x in range(self._image.size[0]):
 197             for y in range(self._image.size[1]):
 198                 self._image.putpixel((x,y),
 199                      int(random.normal(self._image.getpixel((x,y)), ecarttype)))
 200
 201
 202     def bruitUniforme(self, ecart):
 203         '''
 204         Ajoute un bruit uniforme.
 205         '''
 206         for x in range(self._image.size[0]):
 207             for y in range(self._image.size[1]):
 208                 self._image.putpixel((x,y),
 209                                      self._image.getpixel((x,y)) + \
 210                                      int(random.uniform(-ecart,ecart)))
 211
 212
 213     """