Automatically Remove Hot/Dead Pixels from CCD Camera Images in Python: Using NumPy & SciPy to Handle Persistent and Temporary Stuck Pixels

Table of Contents#

1. Understanding Hot/Dead/Stuck Pixels
2. Tools: NumPy & SciPy for Image Processing
3. Step 1: Load and Preprocess the Image
4. Step 2: Detecting Hot/Dead Pixels
   • 4.1 Local Median Filtering for Contextual Detection
   • 4.2 Thresholding to Identify Outliers
5. Step 3: Correcting Defective Pixels
6. Handling Persistent vs. Temporary Pixels
   • 6.1 Persistent Pixels: Using Dark Frames
   • 6.2 Temporary Pixels: Per-Image Local Correction
7. Evaluation: Validate the Correction
8. Conclusion & Extensions
9. References

1. Understanding Hot/Dead/Stuck Pixels#

CCD sensors contain millions of photodiodes, each converting light into an electrical charge. Defects in manufacturing, thermal noise, or aging can cause some diodes to malfunction:

• Dead Pixels: Permanently non-responsive. They output values far below the sensor’s baseline (e.g., 0 in an 8-bit image) due to failed photodiodes.
• Hot Pixels: Overactive due to thermal excitation or transistor leakage. They output values far above the local background (e.g., 255 in an 8-bit image), even in darkness.
• Stuck Pixels: Locked to a fixed value (e.g., mid-range gray) regardless of light input, often due to shorted circuits.

These defects are problematic because:

• In scientific imaging, they corrupt quantitative data (e.g., intensity measurements).
• In astrophotography, hot pixels mimic stars; dead pixels erase faint features.
• In industrial inspection, they can trigger false defect alerts.

2. Tools: NumPy & SciPy for Image Processing#

To automate detection and correction, we’ll use Python’s core scientific libraries:

• NumPy: For efficient manipulation of image data as arrays. CCD images are inherently 2D numerical arrays, making NumPy ideal for pixel-wise operations (e.g., thresholding, local statistics).
• SciPy: For advanced signal processing. We’ll use scipy.ndimage for median filtering (to estimate local background) and interpolation (for pixel correction).
• PIL/Pillow or Matplotlib: To load/save images and convert them into NumPy arrays.

3. Step 1: Load and Preprocess the Image#

First, we load the CCD image into a NumPy array. Most CCD images are saved as FITS (astronomy), TIFF, or PNG. For simplicity, we’ll use a grayscale PNG/TIFF and convert it to a NumPy array:

from PIL import Image
import numpy as np
 
# Load image and convert to grayscale (CCD images are often monochrome)
image_path = "ccd_image.tif"
img = Image.open(image_path).convert("L")  # "L" converts to 8-bit grayscale
img_array = np.array(img, dtype=np.float32)  # Convert to float for precision

Preprocessing Notes:

• If working with raw CCD data (e.g., FITS), use astropy.io.fits to load the array.
• Normalize the image to [0, 255] if values are outside this range (e.g., 16-bit CCD data):

  img_array = (img_array - img_array.min()) / (img_array.max() - img_array.min()) * 255

4. Step 2: Detecting Hot/Dead Pixels#

Blindly thresholding pixels (e.g., "all pixels > 240 are hot") fails because bright features (e.g., stars, light sources) or dark features (e.g., shadows) are misclassified. Instead, we use local context: a pixel is defective if it deviates significantly from its neighbors.

4.1 Local Median Filtering for Contextual Detection#

The median of a local neighborhood (e.g., 3x3 or 5x5 pixels) is robust to outliers and approximates the "true" background value at a pixel. By comparing the pixel to its local median, we isolate defects:

• Hot pixels: pixel_value ≫ local_median
• Dead pixels: pixel_value ≪ local_median

SciPy’s ndimage.median_filter efficiently computes this:

from scipy import ndimage
 
# Compute local median (3x3 kernel; adjust size based on expected defect size)
kernel_size = 3
local_median = ndimage.median_filter(img_array, size=kernel_size)

4.2 Thresholding to Identify Outliers#

Next, we measure the difference between the original pixel and its local median. Defects will have extreme differences. We threshold using the standard deviation (σ) of these differences to account for noise:

# Compute difference between pixel and local median
diff = img_array - local_median
 
# Calculate threshold: 3σ (99.7% of non-defective pixels fall within this range)
sigma = np.std(diff)
hot_threshold = 3 * sigma  # Hot pixels: diff > threshold
dead_threshold = -3 * sigma  # Dead pixels: diff < threshold
 
# Create masks for hot and dead pixels
hot_mask = diff > hot_threshold
dead_mask = diff < dead_threshold
stuck_mask = (diff > -0.5 * sigma) & (diff < 0.5 * sigma) & (img_array == img_array[0,0])  # Example for stuck pixels

Masks are boolean arrays where True indicates a defective pixel.

5. Step 3: Correcting Defective Pixels#

Once defects are detected, replace them with values consistent with their neighbors. Common strategies:

• Median Replacement: Use the local median (already computed) for robustness to noise.
• Bilateral Filtering: Preserve edges while smoothing (for color images).
• Interpolation: For larger defects, use bilinear/bicubic interpolation (via ndimage.map_coordinates).

Here, we use median replacement for simplicity:

# Combine all defect masks
defect_mask = hot_mask | dead_mask | stuck_mask
 
# Replace defective pixels with local median
corrected_img = img_array.copy()
corrected_img[defect_mask] = local_median[defect_mask]

6. Handling Persistent vs. Temporary Pixels#

Defects fall into two categories: persistent (fixed location across images) and temporary (appear randomly due to temperature/noise).

6.1 Persistent Pixels: Using Dark Frames#

Persistent defects (e.g., manufacturing flaws) appear in the same location across all images. To identify them:

1. Capture dark frames: Images taken with the shutter closed (no light) at the same exposure/temperature as science images.
2. Average multiple dark frames to reduce noise, revealing fixed hot/dead pixels.

import glob
 
# Load and average 10 dark frames to reduce noise
dark_frames = [np.array(Image.open(path).convert("L")) for path in glob.glob("dark_frame_*.tif")]
avg_dark = np.mean(dark_frames, axis=0)  # Shape: (height, width)
 
# Detect persistent hot pixels in dark frames (no light, so any bright pixel is hot)
persistent_hot_mask = avg_dark > 200  # Threshold based on dark frame noise

Use this persistent_hot_mask to correct all science images, avoiding re-detection.

6.2 Temporary Pixels: Per-Image Local Correction#

Temporary defects (e.g., due to temperature spikes) appear in individual images. For these, use the per-image local median method (Section 4) to dynamically detect and correct outliers.

7. Evaluation: Validate the Correction#

To ensure your method works:

Visual Inspection#

Compare before/after images. Use matplotlib to overlay defect masks:

import matplotlib.pyplot as plt
 
plt.figure(figsize=(12, 6))
plt.subplot(121), plt.imshow(img_array, cmap="gray"), plt.title("Original (Hot Pixels Marked)")
plt.scatter(np.where(hot_mask)[1], np.where(hot_mask)[0], c="red", s=5)  # Red dots for hot pixels
plt.subplot(122), plt.imshow(corrected_img, cmap="gray"), plt.title("Corrected")
plt.show()

Quantitative Metrics#

• Mean Squared Error (MSE): If you have a "ground truth" image (e.g., a defect-free version), compute MSE before/after correction.
• Noise Reduction: Check that the standard deviation of the corrected image’s background is lower (defects add noise).

8. Conclusion & Extensions#

We’ve shown how to:

1. Detect hot/dead pixels using local median filtering and σ-thresholding.
2. Correct defects with local median replacement.
3. Handle persistent (via dark frames) and temporary (per-image) defects.

Extensions:

• Adaptive Kernels: Use larger kernels (5x5) for larger defects or smaller kernels (3x3) for high-resolution images.
• Color Images: Apply the method to each RGB channel separately.
• GPU Acceleration: Use CuPy (NumPy-compatible GPU library) for large datasets.
• Machine Learning: Train a model (e.g., U-Net) to detect complex defects in noisy images.

9. References#

• NumPy Documentation: https://numpy.org/doc/
• SciPy ndimage: https://docs.scipy.org/doc/scipy/reference/ndimage.html
• "Hot Pixel Detection and Correction in CCD Images" (2005), Journal of Astronomical Instrumentation.
• Astropy FITS Handling: https://docs.astropy.org/en/stable/io/fits/
• "Digital Image Processing" (Gonzalez & Woods), Pearson.

With this workflow, you can automate defect removal, ensuring CCD images are clean and reliable for scientific, industrial, or astrophotographic applications. Let us know your results in the comments!