Esercitazione 2

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


class Segnale:
    
    # costruttore

    def __init__(self, start: float, stop: float, campionamento: int, y = None, nome = None):
        
        self.nome = nome
        self.x = np.linspace(start, stop, campionamento)  
        self.y = y

    # metodi

    def get_nome(self):

        return self.nome 

    def calcola_energia_media(self):
        
        if self.y is None:
            raise ValueError("segnale non definito")
        
        return np.mean(self.y ** 2)
    
    def calcola_valore_medio(self):
        
        if self.y is None:
            raise ValueError("segnale non definito.")
        
        return np.mean(self.y)

    
    def convoluzione(self, altro_segnale: object, mode='same') -> object:
        
        if self.y is None:
            raise ValueError("segnale non definito.")
        
        output = np.convolve(self.y, altro_segnale.y, mode=mode)
        return Segnale(self.x[0], self.x[-1], 1000, output, f'Convoluzione tra {self.nome} e {altro_segnale.get_nome()}')
    
    def visualizza(self) -> None:
        
        if self.y is None:
            raise ValueError("segnale non definito.")
        plt.plot(self.x, self.y)
        plt.title('Segnale')
        plt.grid(True)
        plt.show()


class SegnaleRect(Segnale):

    # costruttore

    def __init__(self, start: float, stop: float, campionamento: int, supporto: float):
        
        super().__init__(start, stop, campionamento)
        self.supporto = supporto
        self.nome = "Rect"
        self.y = np.where(np.abs(self.x) <= supporto / 2, 1, 0)  


class SegnaleTri(Segnale):

    # costruttore

    def __init__(self, start: float, stop: float, campionamento: int, supporto: float):
       
        super().__init__(start, stop, campionamento)
        self.supporto = supporto
        self.nome = "Tri"
        self.y = np.where(np.abs(self.x) <= supporto, 1 - np.abs(self.x) / supporto, 0) 

# funzioni

def visualizza_multi(segnali: list) -> None:
        
        n = len(segnali)  
        plt.figure(figsize=(10, 4 * n))  
        
        for i in range(len(segnali)):

            plt.subplot(n, 1, i + 1)
            plt.plot(segnali[i].x, segnali[i].y)
            plt.title(f'Segnale {i + 1} -> {segnali[i].get_nome()}')
            plt.grid(True)
        
        plt.tight_layout()
        plt.show()

def visualizza_statistiche(segnale: object) -> None:

    if segnale.y is None:
        raise ValueError("segnale non definito")
    
    valore_medio = segnale.calcola_valore_medio()
    energia = segnale.calcola_energia_media()

    plt.figure(figsize=(10, 6))
    plt.plot(segnale.x, segnale.y, label='Segnale')
    plt.axhline(valore_medio, color='r', linestyle='--', label=f'Valore medio: {valore_medio:.2f}')

    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
    plt.text(0.05, 0.95, f'Energia: {energia:.2f}', transform=plt.gca().transAxes, fontsize=12,
             verticalalignment='top', bbox=props)

    plt.title('Segnale con Valore Medio e Energia')
    plt.xlabel('Tempo')
    plt.ylabel('Ampiezza')
    plt.grid(True)
    plt.legend()
    plt.show()



def main():

    tri = SegnaleTri(-5, 5, 1000, 1)
    rect = SegnaleRect(-5, 5, 1000, 0.5)
    conv = tri.convoluzione(rect)
    visualizza_multi([tri, rect, conv])
    visualizza_statistiche(conv)


if __name__ == "__main__":
    main()