Introduction to Signal Processing with Python

Signal processing is the analysis, manipulation, and synthesis of signals, which can be audio, video, or any other form of data that varies over time or space. Python, along with its powerful libraries like NumPy, SciPy, and Matplotlib, provides a convenient and efficient environment for signal processing tasks.

Importing Libraries

Before we start, we need to import the necessary libraries for signal processing in Python.

Code:

import numpy as np
import matplotlib.pyplot as plt

Generating a Signal

Let's start by generating a simple sinusoidal signal using NumPy.

Code:

sample_rate = 1000  # Sample rate in Hz
duration = 1  # Duration in seconds
time = np.linspace(0, duration, int(sample_rate * duration), False)
frequency = 5  # Signal frequency in Hz
amplitude = 1  # Signal amplitude

signal = amplitude * np.sin(2 * np.pi * frequency * time)

Plotting the Signal

We can visualize the generated signal using Matplotlib.

Code:

plt.figure(figsize=(8, 4))
plt.plot(time, signal)
plt.title('Sinusoidal Signal')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.show()

Filtering Signals

Filtering is a common operation in signal processing, used to remove unwanted frequencies or components from a signal. SciPy provides various filtering functions.

Code:

from scipy import signal

# Generate a noisy signal
noisy_signal = signal + np.random.normal(0, 0.1, len(signal))

# Apply a low-pass filter
cutoff_frequency = 10  # Cutoff frequency in Hz
nyquist_frequency = sample_rate / 2
normalized_cutoff = cutoff_frequency / nyquist_frequency
order = 4  # Filter order

filtered_signal = signal.butter(order, normalized_cutoff, btype='low', analog=False)
filtered_signal = signal.filtfilt(b, a, noisy_signal)

Spectral Analysis

Spectral analysis is the study of the frequency content of a signal. The Fast Fourier Transform (FFT) is a widely used tool for this purpose.

Code:

fft_signal = np.fft.fft(signal)
frequencies = np.fft.fftfreq(len(signal), 1 / sample_rate)

plt.figure(figsize=(8, 4))
plt.plot(frequencies, np.abs(fft_signal))
plt.title('Signal Spectrum')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Amplitude')
plt.show()

Audio Signal Processing

Python can be used for processing audio signals, such as those from speech or music recordings.

Code:

import scipy.io.wavfile as wav

# Load an audio file
sample_rate, audio_data = wav.read('audio_file.wav')

# Perform some processing on the audio data
processed_audio = audio_data / np.max(np.abs(audio_data))  # Normalize the audio

# Save the processed audio
wav.write('processed_audio.wav', sample_rate, processed_audio.astype(np.int16))

Image Processing

Signal processing techniques can also be applied to image data, which can be treated as a 2D signal.

Code:

import cv2

# Load an image
image = cv2.imread('image.jpg')

# Convert to grayscale
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply a Gaussian blur filter
blurred_image = cv2.GaussianBlur(gray_image, (5, 5), 0)

# Display the processed image
cv2.imshow('Blurred Image', blurred_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Convolution

Convolution is a fundamental operation in signal processing, used for filtering, correlation, and other applications.

Code:

import numpy as np

# Define two signals
signal1 = np.array([1, 2, 3, 4])
signal2 = np.array([0, 1, 0.5, 0.25])

# Compute the convolution
convolved_signal = np.convolve(signal1, signal2)

print(convolved_signal)

Correlation

Correlation is a measure of the similarity between two signals as a function of the time lag applied to one of them.

Code:

import numpy as np

# Define two signals
signal1 = np.array([1, 2, 3, 4])
signal2 = np.array([4, 3, 2, 1])

# Compute the cross-correlation
correlated_signal = np.correlate(signal1, signal2, mode='full')

print(correlated_signal)

Signal Interpolation

Signal interpolation is the process of estimating the values of a signal at positions between the known sample points.

Code:

import numpy as np
from scipy import interpolate

# Define the original signal
original_signal = np.array([1, 2, 3, 4, 5])
original_time = np.linspace(0, 1, len(original_signal))

# Generate a finer time array for interpolation
interpolated_time = np.linspace(0, 1, 100)

# Perform cubic spline interpolation
interpolated_function = interpolate.interp1d(original_time, original_signal, kind='cubic')
interpolated_signal = interpolated_function(interpolated_time)

Signal Resampling

Signal resampling is the process of changing the sampling rate of a signal, either upsampling (increasing the sampling rate) or downsampling (decreasing the sampling rate).

Code:

import scipy.signal as signal

# Define the original signal
original_signal = np.array([1, 2, 3, 4, 5])
original_sample_rate = 1000

# Upsample the signal by a factor of 2
upsampled_signal = signal.resample(original_signal, len(original_signal) * 2)
upsampled_sample_rate = original_sample_rate * 2

# Downsample the signal by a factor of 2
downsampled_signal = signal.resample(original_signal, len(original_signal) // 2)
downsampled_sample_rate = original_sample_rate // 2

Introduction to Signal Processing with Python

Meta

More in Scientific and math computing