如何不借助Python第三方包将RGB图像转换为灰度图？

Great question! Ditching pre-built libraries to handle this yourself is a fantastic way to understand the fundamentals of image processing. Let’s break down exactly how to do it, starting with the core theory and moving to practical code.

First, the key idea: converting RGB to grayscale relies on calculating a luminance value for each pixel—this represents how bright the pixel appears to the human eye. The industry-standard formula (from ITU-R BT.601) uses weighted values because our eyes are most sensitive to green, least to blue:

Grayscale = 0.299 * Red + 0.587 * Green + 0.114 * Blue

Skipping the weights and just averaging RGB values will give you a washed-out, less accurate result, so stick to this formula!

Example: Convert a BMP Image (No Libraries) #

BMP is an uncompressed format, making it easy to parse manually without dependencies. Here’s a complete function that reads a 24-bit RGB BMP, converts it to grayscale, and saves the result:

def rgb_to_grayscale_bmp(input_path, output_path):
    # Read the original BMP file
    with open(input_path, 'rb') as f:
        # Grab the first 54 bytes (BMP header)
        header = f.read(54)
        
        # Extract critical details from the header
        width = int.from_bytes(header[18:22], 'little')
        height = int.from_bytes(header[22:26], 'little')
        bits_per_pixel = int.from_bytes(header[28:30], 'little')
        
        # This example only works with 24-bit RGB BMPs
        if bits_per_pixel != 24:
            raise ValueError("This function supports only 24-bit RGB BMP files")
        
        # BMP rows are padded to 4-byte boundaries—calculate row size
        row_size = (width * 3 + 3) // 4 * 4
        pixel_data_size = row_size * height
        
        # Read all pixel data
        pixel_data = f.read(pixel_data_size)
    
    # Convert each RGB pixel to grayscale
    grayscale_data = bytearray()
    for y in range(height):
        for x in range(width):
            # BMP stores pixels in BGR order, not RGB—important!
            idx = y * row_size + x * 3
            blue = pixel_data[idx]
            green = pixel_data[idx + 1]
            red = pixel_data[idx + 2]
            
            # Calculate luminance and clamp to 0-255
            gray = int(round(0.299 * red + 0.587 * green + 0.114 * blue))
            grayscale_data.append(gray)
        
        # Add padding to keep rows aligned to 4 bytes
        padding = row_size - (width * 3)
        grayscale_data.extend(b'\x00' * padding)
    
    # Create a new header for the 8-bit grayscale BMP
    new_header = bytearray(header)
    new_header[28:30] = (8).to_bytes(2, 'little')  # 8 bits per pixel
    new_header[34:38] = (len(grayscale_data)).to_bytes(4, 'little')  # Update pixel data size
    new_header[2:6] = (54 + 256 * 4 + len(grayscale_data)).to_bytes(4, 'little')  # Total file size
    
    # Create a grayscale color palette (256 entries, each RGB value matches the gray level)
    palette = bytearray()
    for i in range(256):
        palette.extend([i, i, i, 0])  # BGR + reserved byte
    
    # Write the final grayscale BMP
    with open(output_path, 'wb') as f:
        f.write(new_header)
        f.write(palette)
        f.write(grayscale_data)

# Test it out!
rgb_to_grayscale_bmp('sample.bmp', 'grayscale_output.bmp')

Quick Notes: #

• BMP Quirks: Remember that BMP stores pixels in BGR order, not RGB, and pads each row to a 4-byte boundary—our code handles both of these.
• Other Formats: JPG/PNG use compression, so parsing them manually would require writing decompression logic (which gets very complex). Stick to BMP for learning purposes.
• In-Memory Arrays: If you already have RGB pixel data in a list (e.g., [[(R, G, B), ...], ...]), the conversion is even simpler:

  def rgb_array_to_grayscale(rgb_array):
      grayscale = []
      for row in rgb_array:
          gray_row = [int(round(0.299*r + 0.587*g + 0.114*b)) for r, g, b in row]
          grayscale.append(gray_row)
      return grayscale
  

内容的提问来源于stack exchange，提问作者Knowledge Seeker