--- a/transformations/BruitGauss.py	Thu Feb 11 11:55:03 2010 -0500
+++ b/transformations/BruitGauss.py	Thu Feb 11 16:34:25 2010 -0500
@@ -28,23 +28,21 @@
 
 class BruitGauss():
     
-    def __init__(self):
-        self.proportion_bruit=0.1 #Le pourcentage des pixels qui seront bruites
-        self.nb_chng=10 #Le nombre de pixels changes. Seulement pour fin de calcul
-        self.sigma_gauss=3.0  #L'ecart type du noyau gaussien
-        self.grandeur=7 #Largeur de la fenetre gaussienne
-        self.effectuer=1   #1=effectuer et 0=rien faire
+    def __init__(self,complexity=1):
+        self.nb_chngmax =10 #Le nombre de pixels changes. Seulement pour fin de calcul
+        self.grandeurmax = 20
+        self.sigmamax = 6.0
+        self.regenerate_parameters(complexity)
         
     def get_settings_names(self):
-        return ['proportion_bruit','sigma_gauss','grandeur','effectuer']
+        return ['nb_chng','sigma_gauss','grandeur','effectuer']
 
     def regenerate_parameters(self, complexity):
-        self.proportion_bruit = float(complexity)/25 
-        self.nb_chng=int(1024*self.proportion_bruit)
+        self.nb_chng=3+int(numpy.random.rand()*self.nb_chngmax*complexity)
         
         if float(complexity) > 0:
-            self.sigma_gauss=max(0,numpy.random.normal(complexity*5,complexity))
-            self.grandeur=int(min(31,max(1,8*complexity*numpy.random.normal(1,float(complexity)/2))))
+            self.sigma_gauss=2.0 + numpy.random.rand()*self.sigmamax*complexity
+            self.grandeur=12+int(numpy.random.rand()*self.grandeurmax*complexity)
             self.effectuer =numpy.random.binomial(1,0.25)    ##### On a 25% de faire un bruit #####
         else:
             self.effectuer = 0
@@ -52,58 +50,59 @@
             self.grandeur=1
         #Un peu de paranoia ici, mais on ne sait jamais
         
-        if self.grandeur%2 == 0:
-            self.grandeur+=1    #Toujours un nombre impair, plus simple plus tard
+        #creation du noyau gaussien
+        self.gauss=numpy.zeros((self.grandeur,self.grandeur))
+        x0 = y0 = self.grandeur/2.0
+        for i in xrange(self.grandeur):
+            for j in xrange(self.grandeur):
+                self.gauss[i,j]=numpy.exp(-((i-x0)**2 + (j-y0)**2) / self.sigma_gauss**2)
+        #creation de la fenetre de moyennage
+        self.moy=numpy.zeros((self.grandeur,self.grandeur))
+        x0 = y0 = self.grandeur/2
+        for i in xrange(0,self.grandeur):
+            for j in xrange(0,self.grandeur):
+                self.moy[i,j]=((numpy.sqrt(2*(self.grandeur/2.0)**2) - numpy.sqrt(numpy.abs(i-self.grandeur/2.0)**2+numpy.abs(j-self.grandeur/2.0)**2))/\
+                                numpy.sqrt((self.grandeur/2.0)**2))**5
+
         return self._get_current_parameters()
 
     def _get_current_parameters(self):
-        return [self.proportion_bruit,self.sigma_gauss,self.grandeur,self.effectuer]
+        return [self.nb_chng,self.sigma_gauss,self.grandeur,self.effectuer]
 
     
     def transform_image(self, image):
         if self.effectuer == 0:
             return image
         image=image.reshape((32,32))
-
-        #creation du noyau gaussien
-        gauss=numpy.zeros((self.grandeur,self.grandeur))
-        x0 = y0 = self.grandeur/2
-        for i in xrange(0,self.grandeur):
-            for j in xrange(0,self.grandeur):
-                gauss[i,j]=numpy.exp(-4*numpy.log(2) * ((i-x0)**2 + (j-y0)**2) / self.sigma_gauss**2)
-        #pylab.contour(gauss)
-        #pylab.show()   #Pour voir si la gaussienne est bien comme desiree
-        
-        #Chaque tour dans la boucle ajoute un pointpoivre et sel, puis
-        #y ajoute un bruit gaussien autour afin d'avoir de la correlation dans
-        #les points
+        filtered_image = ndimage.convolve(image,self.gauss,mode='constant')
+        assert image.shape == filtered_image.shape
+        filtered_image = (filtered_image - filtered_image.min() + image.min()) / (filtered_image.max() - filtered_image.min() + image.min()) * image.max()
+               
+        #construction of the moyennage Mask
+        Mask = numpy.zeros((32,32))
         
         for i in xrange(0,self.nb_chng):
             x_bruit=int(numpy.random.randint(0,32))
             y_bruit=int(numpy.random.randint(0,32))
-            #l'overlap n'est pas dramatique. Pas besoin de mecanisme pour s'en proteger
-            image[x_bruit,y_bruit]=max(0,min(1,numpy.random.normal(0.4,self.proportion_bruit*20)))
-            
-            bord = int((self.grandeur-1)/2)
-            #Faire le "smooting"
-            for x in xrange(0,self.grandeur):
-                for y in xrange(0,self.grandeur):
-                    #pour etre certain de ne pas changer le vide
-                    if x_bruit-bord+x < 0:
-                        continue
-                    if y_bruit-bord+y < 0:
-                        continue
-                    if x_bruit-bord+x > 31:
-                        continue
-                    if y_bruit-bord+y > 31:
-                        continue
-                    image[x_bruit-bord+x,y_bruit-bord+y]=max(image[x_bruit-bord+x,y_bruit-bord+y],gauss[x,y]*image[x_bruit,y_bruit])
-                    #image[x_bruit-bord+x,y_bruit-bord+y]=min(1,image[x_bruit-bord+x,y_bruit-bord+y]*(1+gauss[x,y]))
-                    #Cette derniere ligne n'est pas très interessante. Elle ajoute le bruit
-                    #plutot que de prendre le max entre la valeur presente et le bruit. Ca rend l'image un peu 
-                    #chaostique, pas une bonne idee
+            offsetxmin = 0
+            offsetxmax = 0
+            offsetymin = 0
+            offsetymax = 0
+            if x_bruit < self.grandeur / 2:
+                offsetxmin = self.grandeur / 2 - x_bruit
+            if 32-x_bruit < numpy.ceil(self.grandeur / 2.0):
+                offsetxmax = numpy.ceil(self.grandeur / 2.0) - (32-x_bruit)
+            if y_bruit < self.grandeur / 2:
+                offsetymin = self.grandeur / 2 - y_bruit
+            if 32-y_bruit < numpy.ceil(self.grandeur / 2.0):
+                offsetymax = numpy.ceil(self.grandeur / 2.0) - (32-y_bruit)
+            print x_bruit, y_bruit , offsetxmin, offsetxmax, offsetymin, offsetymax, self.grandeur
+            Mask[x_bruit - self.grandeur/2 + offsetxmin : x_bruit + numpy.ceil(self.grandeur/2.0) - offsetxmax,\
+                    y_bruit - self.grandeur/2 + offsetymin : y_bruit + numpy.ceil(self.grandeur/2.0)-  offsetymax] +=\
+                        self.moy[offsetxmin:self.grandeur - offsetxmax,offsetymin:self.grandeur - offsetymax] 
+        print Mask.max(), Mask.min()
                     
-        return image
+        return numpy.asarray((image + filtered_image*Mask)/(Mask+1),dtype='float32')
 
 #---TESTS---