Per i nostri scopi, un sistema è un qualsiasi blocco di elaborazione che, presa in ingresso una sequenza di campioni xn x n , produce in uscita una sequenza di campioni yn y n . Se i campioni vengono da una serie temporale si parla di sistemi a tempo discreto. In questo modulo non ci occuperemo di elaborazione nel tempo continuo, anche se i principi descritti si possono generalizzare anche al caso di segnali di variabile continua. Invece, la sequenza di numeri può provenire dal campionamento di una immagine, e in questo caso sarà opportuno parlare di sistemi a spazio discreto e usare due indici m m e n n se il campionamento avviene mediante griglia rettangolare di righe e colonne.

In questo modulo ci occupiamo soltanto di sistemi lineari, intendendo con questo che vale il

Un altro concetto importante è quello della invarianza rispetto al tempo ovvero, analogamente, rispetto allo spazio. Casi di non invarianza si riscontrano laddove il sistema cambia le proprie caratteristiche nel tempo (o nello spazio), per esempio per effetto di controllo umano. Sono non invarianti anche quei sistemi per i quali la frequenza di campionamento del segnale di ingresso è diversa da quella del segnale di uscita. Ad esempio, i decimatori sono sistemi varianti nel tempo.

Una connessione in serie di blocchi lineari e invarianti rispetto al tempo (Linear Time-Invariant - LTI) è essa stessa un sistema lineare e invariante rispetto al tempo, e l'ordine dei blocchi può essere variato senza che cambi il comportamento ingresso-uscita complessivo.

I sistemi LTI possono essere descritti completamente dalla risposta che forniscono ad un impulso di ampiezza unitaria.

Chiamiamo h h il segnale di uscita di un sistema LTI il cui ingresso sia costituito da un impulso. Tale segnale di uscita viene detto risposta all'impulso. Dal momento che qualsiasi segnale a tempo (spazio) discreto si può pensare come costituito dalla somma pesata di impulsi traslati, ogni campione che si presenta in ingresso attiva una risposta all'impulso con una certa ampiezza determinata dal valore del campione stesso. Dal momento che le risposte all'impulso si attivano a distanza di un campione l'una dall'altra ed hanno una estensione di svariati campioni, l'effetto di ciascun campione di input si protrae nel tempo, ovvero si estende su un certo numero di campioni successivi del segnale di output. Vista la linearità e l'invarianza temporale del sistema, le successive risposte all'impulso sommano i loro effetti. In altri termini, il sistema mantiene memoria dei campioni passati, cioè immessi in precedenza nel sistema, e usa questa memoria per influenzare il presente.

Per avere una analogia fisica, si può pensare alla percussione a intervalli regolari di un piatto musicale. La risposta ad ogni singolo colpo si protrae nel tempo e si sovrappone alle risposte ad ogni colpo successivo.

Per generalizzazione dell'esempio Esempio 1 si può definire l'operazione di convoluzione.

L'operazione di convoluzione può essere pienamente intesa attraverso la costruzione esplicita di qualche esempio di prodotto di convoluzione. Il modulo Discrete-Time Convolution offre la costruzione grafica di un esempio e rimanda a ulteriori esempi disponibili in rete.

La trasformata di Fourier della risposta all'impulso viene chiamata Risposta in Frequenza e si indica con Hω H ω . La trasformata di Fourier dell'uscita del sistema si ottiene dalla trasformata di Fourier dell'ingresso mediante moltiplicazione per la risposta in frequenza, cioè Yω=HωXω Y ω H ω X ω .

La risposta in frequenza sagoma, in maniera moltiplicativa, lo spettro del segnale di ingresso o, in altri termini, opera un filtraggio esaltando talune frequenze ed attenuandone altre. Il filtraggio può operare anche sulla fase delle componenti spettrali, ritardandole in misura diversa.

Il filtraggio può avvenire nel dominio del tempo (o dello spazio), mediante operazione di convoluzione, o nel dominio delle frequenze mediante moltiplicazione per la risposta in frequenza.

                 
	  void filtra(float[] DATAF, float[] DATA, float WC, float RO) {
	    //WC and R0 are useless, here kept only to avoid rewriting other
	    //parts of code
	    for(int i = 2; i < DATA.length-1; i++){
	      DATAF[i] = DATA[i+1] + 0.5*DATA[i] + 0.25*DATA[i-1];
	      }
	    }
             	      
	  

Le nozioni di risposta all'impulso, convoluzione, risposta in frequenza, e filtraggio si estendono in maniera naturale dal 1D al 2D, e costituiscono concetti fondamentali dell'elaborazione di immagini.

Se x x è l'immagine di interesse, è facile rendersi conto che la convoluzione avviene tramite moltiplicazione e traslazione nello spazio di una maschera di convoluzione o kernel h h (la risposta all'impulso del sistema di elaborazione). Così come nel caso 1D il filtraggio può essere pensato come una combinazione di un gruppo di campioni contigui (dove la estensione del gruppo dipende dalla estensione della risposta all'impulso del filtro) che viene ripetuta nel tempo, campione per campione, così nello spazio il filtraggio può essere visto come una combinazione di una porzione di campioni (insieme pixel contigui), la cui estensione è data dalla maschera di convoluzione. Quella che nel tempo era un effetto della memoria del sistema, nel caso delle immagini diventa una influenza a distanza.

Come nel caso 1D, la trasformata di Fourier della risposta all'impulso viene chiamata Risposta in Frequenza e si indica con H ω X ω Y H ω X ω Y . La trasformata di Fourier dell'uscita del sistema si ottiene dalla trasformata di Fourier dell'ingresso mediante moltiplicazione per la risposta in frequenza, cioè Y ω X ω Y =H ω X ω Y X ω X ω Y Y ω X ω Y H ω X ω Y X ω X ω Y .

                 
for(int y=0; y<height; y++) { 
  for(int x=0; x<width/2; x++) { 
    float sum = 0; 
    for(int k=-n2; k<=n2; k++) { 
      for(int j=-m2; j<=m2; j++) { 
        // Reflect x-j to not exceed array boundary 
        int xp = x-j; 
        int yp = y-k; 
        //... omissis ...
	//auxiliary code to deal with image boundaries   
        sum = sum + kernel[j+m2][k+n2] * red(get(xp, yp)); 
      } 
    } 
    output[x][y] = int(sum);  
  } 
}