C++读取8位灰度BMP图像像素数据时遇到问题求助

Hey there! Let's work through that pixel reading snag you're hitting with your 512×512 8-bit grayscale BMP handler. Even though you initially thought you could set the header aside, there are a few critical details in that data that are likely tripping you up. Here's how to get your pixel reading working smoothly:

• Don't skip header validation entirely
  Even if you're targeting 512×512 images, the BMP header holds non-negotiable info:

  • The dataOffset value tells you exactly where pixel data starts in the file (don't assume it's a fixed 54 bytes—some BMPs have extra metadata).
  • You need to confirm the image is actually 8-bit, uncompressed, and matches your 512×512 requirement to avoid garbage data.
  • BMP rows are padded to 4-byte boundaries (luckily 512 is a multiple of 4, so no padding here, but it's good to code for it anyway).

• Use structured headers instead of raw arrays
  Mapping the BMP headers to C++ structs makes reading and accessing values way easier. Just make sure to disable struct padding so it matches the BMP's binary format:

  #pragma pack(push, 1)
  struct BMPFileHeader {
      uint16_t signature; // Must be 0x4D42 ('BM')
      uint32_t fileSize;
      uint16_t reserved1;
      uint16_t reserved2;
      uint32_t dataOffset; // Pixel data start position
  };
  
  struct BMPInfoHeader {
      uint32_t headerSize;
      int32_t width;
      int32_t height;
      uint16_t planes;
      uint16_t bitsPerPixel; // Should equal 8 for your use case
      uint32_t compression; // Must be 0 (uncompressed)
      uint32_t imageSize;
      int32_t xPixelsPerMeter;
      int32_t yPixelsPerMeter;
      uint32_t colorsUsed;
      uint32_t colorsImportant;
  };
  #pragma pack(pop)
  

• Account for the color table
  8-bit BMPs include a 256-entry color table (each entry is 4 bytes for RGB values). You need to read this before getting to pixel data—even for grayscale, the pixel values are indexes into this table (though grayscale tables are usually linear, so you can treat the index directly as a gray value).

• Read pixels correctly (and handle row order)
  BMP stores pixel data from bottom to top. To get a top-to-bottom pixel array, read rows starting from the last one:

  std::vector<uint8_t> pixelData(width * height);
  int padding = (4 - (width % 4)) % 4; // Calculate padding (0 for 512)
  
  for (int y = height - 1; y >= 0; --y) {
      // Read one row of pixels
      file.read(reinterpret_cast<char*>(&pixelData[y * width]), width);
      // Skip padding bytes if needed
      if (padding > 0) {
          file.seekg(padding, std::ios::cur);
      }
  }
  

• Add error checking
  Always verify that your fstream operations succeeded. Check if (!file) after reads/seeks to catch issues like corrupted files or incorrect paths early.

Example Constructor Implementation #

Here's how you could put this all together in your Image class:

class Image {
private:
    int width, height;
    std::vector<uint8_t> pixelData;

public:
    Image(const std::string& filename) {
        std::ifstream file(filename, std::ios::binary);
        if (!file) {
            throw std::runtime_error("Failed to open BMP file");
        }

        BMPFileHeader fileHeader;
        BMPInfoHeader infoHeader;

        // Read file header
        file.read(reinterpret_cast<char*>(&fileHeader), sizeof(fileHeader));
        if (fileHeader.signature != 0x4D42) {
            throw std::runtime_error("Not a valid BMP file");
        }

        // Read info header
        file.read(reinterpret_cast<char*>(&infoHeader), sizeof(infoHeader));
        if (infoHeader.bitsPerPixel != 8 || infoHeader.compression != 0) {
            throw std::runtime_error("Only uncompressed 8-bit grayscale BMPs are supported");
        }
        if (infoHeader.width != 512 || infoHeader.height != 512) {
            throw std::runtime_error("Image must be 512×512 pixels");
        }

        width = infoHeader.width;
        height = infoHeader.height;

        // Read 256-entry color table
        std::vector<uint32_t> colorTable(256);
        file.read(reinterpret_cast<char*>(colorTable.data()), colorTable.size() * sizeof(uint32_t));

        // Seek to pixel data (redundant here, but safe)
        file.seekg(fileHeader.dataOffset, std::ios::beg);

        // Read pixel data
        pixelData.resize(width * height);
        int padding = (4 - (width % 4)) % 4;

        for (int y = height - 1; y >= 0; --y) {
            file.read(reinterpret_cast<char*>(&pixelData[y * width]), width);
            if (padding > 0) {
                file.seekg(padding, std::ios::cur);
            }
        }

        if (!file) {
            throw std::runtime_error("Failed to read pixel data");
        }
    }

    // Add getters or other methods as needed
    const uint8_t* getPixels() const { return pixelData.data(); }
    int getWidth() const { return width; }
    int getHeight() const { return height; }
};

内容的提问来源于stack exchange，提问作者Floyd Everest