Common window functions in Signal Processing - Mini Project: Build & Apply

Common Window Functions in Signal Processing

📖 Scenario: Imagine you are working on a project to analyze sound signals. To prepare the signals for analysis, you need to apply window functions. Window functions help reduce noise and improve the quality of the signal processing.

🎯 Goal: You will create a small program that generates three common window functions: rectangular, hamming, and hann. Then, you will display their values for a fixed window size.

📋 What You'll Learn

Create a dictionary with window names as keys and empty lists as values

Set a window size variable to 10

Fill the dictionary with values for rectangular, hamming, and hann windows using formulas

Print the dictionary with window names and their values

💡 Why This Matters

🌍 Real World

Window functions are used in audio and signal processing to reduce noise and improve analysis quality by shaping the signal before applying transformations like Fourier transforms.

💼 Career

Understanding and implementing window functions is important for roles in signal processing, audio engineering, and data analysis where clean signal data is crucial.

1

Create the window dictionary

Create a dictionary called windows with keys 'rectangular', 'hamming', and 'hann'. Set each key's value to an empty list.

Signal Processing

# Create the windows dictionary with empty lists
# Your code here

Hint

Use curly braces {} to create a dictionary. Each key should be a string and each value an empty list [].

2

Set the window size

Create a variable called window_size and set it to 10.

Signal Processing

windows = {'rectangular': [], 'hamming': [], 'hann': []}
# Set the window size to 10
# Your code here

Hint

Just assign the number 10 to the variable window_size.

3

Calculate window values

Use a for loop with variable n from 0 to window_size - 1. Inside the loop, calculate and append values for each window in windows using these formulas:

- Rectangular: 1
- Hamming: 0.54 - 0.46 * cos(2 * pi * n / (window_size - 1))
- Hann: 0.5 * (1 - cos(2 * pi * n / (window_size - 1)))

Use math.cos and math.pi. Import math at the top.

Signal Processing

import math

windows = {'rectangular': [], 'hamming': [], 'hann': []}
window_size = 10
# Calculate window values and append to lists
# Your code here

Hint

Use range(window_size) to loop from 0 to 9. Append values to each list inside the dictionary.

4

Print the window values

Print the windows dictionary to display the window names and their calculated values.

Signal Processing

import math

windows = {'rectangular': [], 'hamming': [], 'hann': []}
window_size = 10
for n in range(window_size):
    windows['rectangular'].append(1)
    windows['hamming'].append(0.54 - 0.46 * math.cos(2 * math.pi * n / (window_size - 1)))
    windows['hann'].append(0.5 * (1 - math.cos(2 * math.pi * n / (window_size - 1))))
# Print the windows dictionary
# Your code here

Hint

Use print(windows) to show the dictionary with all window values.

Practice

1. Which of the following window functions is known for having smooth edges and reducing spectral leakage in signal processing?

easy

A. Boxcar window

B. Rectangular window

C. Hamming window

D. Step window

Solution

1. Step 1: Understand window function purpose

   Window functions reduce spectral leakage by smoothing signal edges.

2. Step 2: Identify smooth edge windows

   Hamming window is designed with smooth edges to reduce leakage, unlike rectangular or step windows.

3. Final Answer:

   Hamming window -> Option C

4. Quick Check:

   Smooth edges = Hamming window [OK]

Hint: Smooth edges mean Hamming or Hann window, not rectangular [OK]

Common Mistakes:

• Confusing rectangular window as smooth
• Thinking step window reduces leakage
• Mixing boxcar with smooth windows

2. Which of the following is the correct Python syntax to generate a Hann window of length 64 using NumPy?

easy

A. np.hanning(64)

B. np.hamming(64)

C. np.hann(64)

D. np.window('hann', 64)

Solution

1. Step 1: Recall NumPy window function names

   NumPy uses np.hanning() to generate a Hann window, not np.hann().

2. Step 2: Check other options

   np.hamming() generates Hamming window, np.window() is invalid syntax.

3. Final Answer:

   np.hanning(64) -> Option A

4. Quick Check:

   Hann window in NumPy = np.hanning() [OK]

Hint: Hann window is np.hanning(), not np.hann() [OK]

Common Mistakes:

• Using np.hann() which does not exist
• Confusing Hamming and Hann functions
• Trying np.window() which is invalid

3. What is the output array when applying a Hamming window of length 4 using NumPy's np.hamming(4)?

medium

A. [0.0, 0.5, 0.5, 0.0]

B. [0.08, 0.77, 0.77, 0.08]

C. [1.0, 1.0, 1.0, 1.0]

D. [0.2, 0.6, 0.6, 0.2]

Solution

1. Step 1: Recall Hamming window formula

   Hamming window values for length 4 are approximately [0.08, 0.77, 0.77, 0.08].

2. Step 2: Verify with NumPy output

   Running np.hamming(4) returns array close to [0.08, 0.77, 0.77, 0.08].

3. Final Answer:

   [0.08, 0.77, 0.77, 0.08] -> Option B

4. Quick Check:

   np.hamming(4) ≈ [0.08, 0.77, 0.77, 0.08] [OK]

Hint: Small Hamming windows start and end near 0.08 [OK]

Common Mistakes:

• Assuming window starts at 0.0
• Confusing with rectangular window of all ones
• Mixing values with Hann window

4. The following code attempts to generate a Blackman window but throws an error. What is the error and how to fix it?

import numpy as np
window = np.blackman(32)

medium

A. AttributeError: np.blackman does not exist; use np.blackman_window(32)

B. TypeError: np.blackman expects two arguments

C. SyntaxError: missing parentheses in np.blackman(32)

D. AttributeError: np.blackman does not exist; use scipy.signal.blackman(32)

Solution

1. Step 1: Identify source of Blackman window

   NumPy does not have np.blackman; it's in scipy.signal as scipy.signal.blackman.

2. Step 2: Fix import and function call

   Import scipy.signal and call scipy.signal.blackman(32) to generate the window.

3. Final Answer:

   AttributeError: np.blackman does not exist; use scipy.signal.blackman(32) -> Option D

4. Quick Check:

   Blackman window in scipy.signal, not NumPy [OK]

Hint: Blackman window is in scipy.signal, not NumPy [OK]

Common Mistakes:

• Trying np.blackman which is not in NumPy
• Assuming syntax error instead of attribute error
• Using wrong function name np.blackman_window

5. You want to analyze a noisy signal segment of length 128 samples. Which window function should you apply before Fourier transform to minimize spectral leakage and why?

hard

A. Hamming window, because it reduces side lobes and smooths edges

B. Rectangular window, because it preserves signal amplitude exactly

C. Boxcar window, because it is the simplest and fastest

D. Step window, because it sharply cuts off signal edges

Solution

1. Step 1: Understand spectral leakage and window effects

   Spectral leakage occurs due to sharp edges; smooth windows reduce it.

2. Step 2: Choose window that reduces side lobes and smooths edges

   Hamming window is designed to reduce side lobes and smooth edges, minimizing leakage.

3. Final Answer:

   Hamming window, because it reduces side lobes and smooths edges -> Option A

4. Quick Check:

   Minimize leakage = use Hamming window [OK]

Hint: Use Hamming to smooth edges and reduce leakage [OK]

Common Mistakes:

• Choosing rectangular window which causes leakage
• Confusing boxcar with rectangular window
• Thinking step window helps reduce leakage