import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import firwin
import wave
             

class Signal:
    N = 0 # nombre d'échantillons
    fechant = 0 # fréquence d'échantillonnage
    x = np.zeros(N) # tableau des échantillons
    type = 'aucun'
    def __init__(self,N,fechant): # initialisateur
        self.N = N
        self.fechant = fechant
        self.x = np.zeros(N)
    def tracer(self): # tracer le signal avec matplotlib
        pass
    def enregistrer(self,fichier): # enregistrer le signal dans un fichier texte
        pass
        # utiliser numpy.savetxt
    def lire(self,fichier): # lire le signal dans un fichier texte
        pass
        # utiliser numpy.loadtxt
    def dupliquer(self): # renvoyer une copie du signal
        pass
        # renvoyer un nouvel objet de la classe Signal
    def filtrer(self,filtre):
        pass
        # filtrer avec un objet de la classe Filtre (définie plus loin)
        # renvoie un nouveau signal
             

signal_1 = Signal(1000,10e3) # signal à 1000 échantillons, fréq. d'échantillonnage 10 kHz
               

signal_2 = Signal(1000,10e3) # signal à 1000 échantillons, fréq. d'échantillonnage 10 kHz
               

signal_1.N = 2000 # à proscrire
               

signal_1.enregistrer("signal_1.txt")
                    

Signal.enregistrer(signal_1,"signal_1.txt")
                     

class SignalSinus(Signal):
    amplitude = 0
    frequence = 0
    def __init__(self,N,fechant,amplitude,frequence): 
        Signal.__init__(self,N,fechant)
        self.type = 'sinus'
        self.amplitude = amplitude
        self.frequence = frequence
        #générer le signal sinusoïdal
    def afficher_frequence(self):
        print(self.frequence)
              

signal_sinus_1 = SignalSinus(1000,1e3,1,10)
                   

signal_sinus_1.tracer()
                    

class SignalCarre(Signal):
    amplitude = 0
    frequence = 0
    def __init__(self,N,fechant,amplitude,frequence): 
        Signal.__init__(self,N,fechant)
        self.type = 'carre'
        self.amplitude = amplitude
        self.frequence = frequence
        #générer le signal carré
    def afficher_frequence(self):
        print(self.frequence)
              

class SignalWave(Signal):
    def __init__(self,fichier):
        pass
        # lecture du fichier wave avec le module wave
    def enregistrer_wave(self,fichier):
        pass
              

class Filtre:
    na = 0
    nb = 0
    a = np.zeros(na)
    b = np.zeros(nb)
    type = 'aucun'
    def __init__(self,a,b):
        self.na = len(a)
        self.nb = len(b)
        self.a = np.array(a)
        self.b = np.array(b)
    def tracer(self):
        pass
        # tracé de la réponse fréquentielle
    def appliquer(self,x,y,n):
        pass
        # appliquer le filtre à l'indice n
        # x : signal d'entrée (tableau numpy.ndarray)
        # y : signal de sortie (tableau numpy.ndarray)
    def donner_taille(self):
        return (self.na,self.nb)
            

class FiltreConvolutionPasseBas(Filtre):
    fc = 0 # fréquence de coupure divisée par fechant
    P = 0 # nombre de coefficients = 2*P+1
    def __init__(self,fc,P):
        self.type = 'passe-bas'
        self.fc = fc
        self.P = P
        b = firwin(2*P+1,cutoff=[fc],window='hann',nyq=0.5)
        Filtre.__init__(self,[1],b) 

             

filtre_1 = FiltreConvolutionPasseBas(0.1,10)