For our purposes, a system is any processing element that, given as input a sequence of samples xn x n , produces as output a sequence of samples yn y n . If the samples are coming from a temporal series we talk about discrete-time systems. In this module we will not be concerned with continuous-time processing, even though the principles here described can be generalized to functions of continuous variable. Instead, the sequence of number can come from the sampling of an image, and in this case it will be appropriate to talk of discrete-space systems and use two indeces m m and n n if sampling is done by a rectangular grid of rows and columns.

In this module we are only dealing with linear systems, thus meaning that the following principle holds:

Another important concept is time (and space) invariance. Cases of non-invariance are found whenever the system changes its characteristics in time (or space), for example as an effect of human control. Those systems where the sampling rate at the input is different than the one at the output are also non-invariant. For instance, decimators are time-variant systems.

A series connection of linear time-invariant (LTI) blocks is itself a linear and time-invariant system, and the order of blocks can be changed without affecting the input-output behavior.

LTI systems can be thoroughly described by the response they give to a unit-magnitude impulse.

We call h h the output signal of a LTI system whose input is just an impulse. Such output signal is called impulse response. Since any discrete-time (-space) signal can be thought of as a weighted sum of translated impulses, each sample that shows up to the input activates an impulse response whose amplitude is determined by the value of the sample itself. Moreover, since the impulse responses are activated at a distance of one sampling step from each other and are extended over several samples, the effect of each input sample is distributed over time, on a number of contiguous samples of the output signal. Being the system linear and time-invariant, the successive impulse responses sum their effects. In other words, the system has memory of the past samples, previously given as input to the system, and it uses such memory to influence the present.

To have a physical analogy, we can think of regular strokes of a snare drum. The response to each stroke is distributed in time and overlaps with the responses to the following strokes.

To generalize the example Example 1 we can define the operation of convolution.

The operation of convolution can be fully understood by the explicit construction of some examples of convolution product. The module Discrete-Time Convolution gives the graphic construction of an examples and it offers pointers to other examples.

The Fourier Transform of the impulse response is called Frequency Response and it is represented with Hω H ω . The Fourier transform of the system output is obtained by multiplication of the Fourier transform of the input with the frequency response, i.e., Yω=HωXω Y ω H ω X ω .

The frequency response shapes, in a multiplicative fashion, the input-signal spectrum or, in other words, it performs some filtering by emphasizing some frequency components and attenuating some others. A filtering can also operate on the phases of the spectral components, by delaying them of different amounts.

Filtering can be performed in the time domain (or space domain), by the operation of convolution, or in the frequency domain by multiplication of the frequency response.

                 
	  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];
	      }
	    }
             	      
	  

The notions of impulse response, convolution, frequency response, and filtering naturally extend from 1D to 2D, thus giving the fundamental concepts of image processing.

If x x is the image that we are considering, it is easy to realize that convolution is performed by multiplication and translation in space of a convolution mask or kernel h h (it is the impulse response of the processing system). As in the 1D case filtering could be interpreted as a combination of contiguous samples (where the extension of such cluster depends on the extension of the filter impulse response) that is repeated in time, sample by sample. So, in 2D space filtering can be interpreted as a combination of contiguous samples (pixels) in a cluster, whose extension is given by the convolution mask. The so-called memory of 1-D systems becomes in 2-D a sort of distance effect.

As in the 1D case, the Fourier transform of the impulse response is called Frequency response and it is indicated by H ω X ω Y H ω X ω Y . The Fourier transform of the system output is obtained by Fourier-transforming the input and multiplying the result by the frequency response. 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);  
  } 
}