Riscritta la classe wavelet. Che per altro prima non era scritta, quindi

diff --git a/Filtering/Filtering.py b/Filtering/Filtering.py
index 652fca8..0f8eb67 100644
--- a/Filtering/Filtering.py
+++ b/Filtering/Filtering.py
@@ -48,11 +48,86 @@ def DownSample(samples):
     return array(samples[::2])

 def UpSample(samples):
-
+
     s = zeros(2 * len(samples))
     s[::2] = samples
     return array(s)

+class WaveletTransformedSignal():
+
+    def __init__(self):
+        """
+        Creates a new WaveletTransformedSignal to
+        store the samples from the filterbank
+        """
+        self.samples_number = None
+        self.low_samples = []
+        self.high_samples = []
+
+    def AddHighSamples(self, samples):
+        """
+        Add a new High Sample
+        """
+        if self.samples_number is None:
+            self.samples_number = len(samples)
+            self.high_samples.append(samples)
+        else:
+            if len(samples) != (self.samples_number / 2):
+                raise IndexError("High frequency samples do not have the expected length")
+            else:
+                self.high_samples.append (samples)
+                self.samples_number = len(samples)
+
+    def AddLowSamples(self, samples):
+        """
+        Add the Low samples
+        """
+        if self.samples_number != len(samples):
+            raise IndexError("Low frequency samples do not have the expected length")
+        else:
+            self.low_samples.append(samples)
+
+    def GetLowSamples(self):
+        """
+        Get the low frequency samples
+        """
+        try:
+            return self.low_samples.pop()
+        except:
+            return None
+
+    def GetLowSamplesLength(self):
+        """Get the length of the lowsample array"""
+        try:
+            return len(self.low_samples)
+        except:
+            return None
+
+    def GetNumSamples(self):
+        """Return samples num"""
+        return len(self.low_samples) + len(self.high_samples)
+
+    def GetSamplesMax(self):
+        """Get the maximum abs value of the lowsample and
+        high sample array"""
+        m = [0]
+        for low in self.low_samples:
+            m.append (max(abs(low)))
+        for high in self.high_samples:
+            m.append(max(abs(high)))
+        return max(m)
+
+    def GetHighSamples(self):
+        """
+        Get the high frequency samples
+        """
+
+        try:
+            ret = self.high_samples.pop ()
+            return ret
+        except:
+            return None
+

 class FilterBank():

@@ -158,17 +233,18 @@ class FilterBank():
         method.
         """

-        samplesArray = []
+        # samplesArray = []
+        samplesArray = WaveletTransformedSignal()
         low = self._Truncate(samples)

         # Do the real filtering and downsampling. Store the downsampled
         # details in the array.
         for recursion in xrange(0, self.depth):
-            samplesArray.append (DownSample (self.highPassFilter (low)))
+            samplesArray.AddHighSamples (DownSample (self.highPassFilter (low)))
             low = DownSample (self.lowPassFilter (low))

         # In the end append the low downsampled data to the array
-        samplesArray.append (low)
+        samplesArray.AddLowSamples (low)

         return samplesArray

@@ -178,12 +254,15 @@ class FilterBank():
         method.
         """

-        low = sampleArray.pop ()
+        low = sampleArray.GetLowSamples ()
+
+        counter = 0

-        # Iterate over the reversed array
-        for high in sampleArray[::-1]:
+        high = sampleArray.GetHighSamples ()
+        while(high != None):
             low = self.lowPassInverseFilter (UpSample (low))
             low += self.highPassInverseFilter (UpSample (high))
+            high = sampleArray.GetHighSamples ()

             # Facciamo shiftare l'array in modo che il delay dei sample
             # ricostruiti non disturbi la ricostruzione dei prossimi.
diff --git a/Filtering/dwt b/Filtering/dwt
index 0ae6b82..028fb1a 100755
--- a/Filtering/dwt
+++ b/Filtering/dwt
@@ -142,27 +142,36 @@ class DWT():
         """
         Shows the result of filtering
         """
-        scale = 1
-        singleOffset = 2 * max(abs(wavelets[-1]))
+        scale = pow(2, wavelets.GetNumSamples ())
+        singleOffset = 2 * wavelets.GetSamplesMax()
         offset = -3 * singleOffset
-        # We plot only the first 2000 samples, to avoid memory
+        # We plot only the first 1000000 samples, to avoid memory
         # being flooded with our data :)
         toPlot = 1000000
-        for samples in wavelets[0:-1]:
+
+        # Stampo i low
+        scale = int(0.5 * scale)
+        low = wavelets.GetLowSamples()
+        data = low[:toPlot / scale]
+        print len(low), len(data), scale
+        axes = range(0, len(data) * scale, scale)
+
+        plot(axes, data + offset)
+
+        offset += singleOffset
+
+        samples = wavelets.GetHighSamples ()
+        while samples is not None:

             data = samples[0:toPlot / scale]
             axes = range(0, len(data) * scale , scale)

             plot (axes, data + offset)
             offset += singleOffset
-            scale = 2*scale
-
-        # Stampo i low
-        scale = int(0.5 * scale)
-        data = wavelets[-1][:toPlot / scale]
-        axes = range(0, len(data) * scale, scale)
+            scale = int(0.5*scale)
+
+            samples = wavelets.GetHighSamples ()

-        plot(axes, data + offset)
         show ()


diff --git a/Slide/slide.tex b/Slide/slide.tex
index be2cd5a..307e5e5 100644
--- a/Slide/slide.tex
+++ b/Slide/slide.tex
@@ -224,10 +224,12 @@
 	\vskip 25pt

 	Consideriamo un segnale generico $x(n)$, e la sua trasformata di Fourier $X(\omega)$.
-	La trasformata di Fourier del segnale $y(n)$ ottenuto dopo l'applicazione del filtro
-	sarà il prodotto di $X(\omega)$ e di $H(\omega)$\footnote{che in effetti è la trasformata
-	di Fourier del filtro considerato come funzione da $\R$ in $\R$.}.
-
+	La trasformata di Fourier $Y(\omega)$ del segnale $y(n)$ ottenuto dopo l'applicazione del filtro
+	sarà
+	\[
+		Y(\omega) = X(\omega) H(\omega)
+	\]
+
 	\vskip 25pt

 	Il filtro \textbf{amplifica ogni frequenza del segnale} di un coefficiente $H(\omega)$.