logo标签列表

在BMP文件中读取像素值

c++cimagebmpdev-c++
13

如何在Windows上使用C或C++读取24位BMP图像所有像素[h * w]的颜色值，最好不使用任何第三方库。我使用了Dev-C ++
如果能提供工作代码将非常感谢，因为我从未涉及过图像读取，通过谷歌搜索后来到这里[如果您能比我更好地使用谷歌，请提供链接]。

8
只需一秒钟的谷歌搜索即可了解“BMP文件格式”：http://zh.wikipedia.org/wiki/BMP文件格式 - Marc B
6个回答
52

以下代码片段不完整，包含许多隐藏的假设和错误。我仅通过观察为大学课程项目从零开始编写了它，使其最小限度地满足了所有要求。我没有再进行更多的工作，因为肯定有库可以更好地完成这项工作。

以下是它能够正常运行的条件（某些假设在注释中指出）：

  1. 它在Windows上运行，其他平台不确定
  2. 它适用于24位颜色BMP图像
  3. 它假设图像的宽度是4的倍数，如果不是，则不处理填充字节
  4. 它将图像宽度和高度解码为32位小端整数
  5. 它返回指向动态分配内存的指针，如果未被调用者释放，可能会导致内存泄漏

其他答案已经涵盖了其中一些问题。

你可以尝试这个：

unsigned char* readBMP(char* filename)
{
    int i;
    FILE* f = fopen(filename, "rb");
    unsigned char info[54];

    // read the 54-byte header
    fread(info, sizeof(unsigned char), 54, f); 

    // extract image height and width from header
    int width = *(int*)&info[18];
    int height = *(int*)&info[22];

    // allocate 3 bytes per pixel
    int size = 3 * width * height;
    unsigned char* data = new unsigned char[size];

    // read the rest of the data at once
    fread(data, sizeof(unsigned char), size, f); 
    fclose(f);

    for(i = 0; i < size; i += 3)
    {
            // flip the order of every 3 bytes
            unsigned char tmp = data[i];
            data[i] = data[i+2];
            data[i+2] = tmp;
    }

    return data;
}

现在，data 应该包含像素的 (R, G, B) 值。像素 (i, j) 的颜色存储在 data[3 * (i * width + j)]、data[3 * (i * width + j) + 1] 和 data[3 * (i * width + j) + 2] 中。

在最后部分，交换每个第一个和第三个像素是因为我发现颜色值被存储为(B,G,R)三元组，而不是(R,G,B)。

6
如果您正在阅读一个24位颜色的BMP文件，您还需要注意行填充。由于某些原因，BMP期望所有行在字节倍数为4的情况下对齐。您可以通过以下公式计算填充量：int row_padded = (width*3 + 3) & (~3)然后，您使用fread()读取一行row_padded个字节，但只使用宽度元素。其余部分将被丢弃... - dominikschnitzer
6
请注意上述函数存在一些缺陷，涉及图像宽度和高度的赋值：1. 它假设采用小端字节序。如果是大端平台，则无法正常工作。2. 它假设 sizeof(int) 为4。如果不是，则无法正常工作。 - Robin Hsu
这个答案有一个错误，请查看我的评论以获取更新 https://dev59.com/KWox5IYBdhLWcg3wTina#43140660 - Owen Morgan
16

在填充修复后的readBMP函数代码:

unsigned char* ReadBMP(char* filename)
{
    int i;
    FILE* f = fopen(filename, "rb");

    if(f == NULL)
        throw "Argument Exception";

    unsigned char info[54];
    fread(info, sizeof(unsigned char), 54, f); // read the 54-byte header

    // extract image height and width from header
    int width = *(int*)&info[18];
    int height = *(int*)&info[22];

    cout << endl;
    cout << "  Name: " << filename << endl;
    cout << " Width: " << width << endl;
    cout << "Height: " << height << endl;

    int row_padded = (width*3 + 3) & (~3);
    unsigned char* data = new unsigned char[row_padded];
    unsigned char tmp;

    for(int i = 0; i < height; i++)
    {
        fread(data, sizeof(unsigned char), row_padded, f);
        for(int j = 0; j < width*3; j += 3)
        {
            // Convert (B, G, R) to (R, G, B)
            tmp = data[j];
            data[j] = data[j+2];
            data[j+2] = tmp;

            cout << "R: "<< (int)data[j] << " G: " << (int)data[j+1]<< " B: " << (int)data[j+2]<< endl;
        }
    }

    fclose(f);
    return data;
}
4
@arc_lupus 返回了“data”。当调用者使用完“data”后需要执行“delete”操作。 - rubenvb
可能错了，但我认为这段代码有个打字错误。所需的内存量是3 宽度高度，而不是row_padded。 row_padded仅在读取文件时需要。 - John Smith
@JohnSmith 但他确实在读取文件，所以填充是可以的吗？所以如果你的图像每行有121个像素，准备读取124个并丢弃最后3个 - 如果我理解正确的话。 - jiggunjer
据我所知，他在一遍又一遍地将每一行存储在data数组中。当函数返回时，他只会拥有图像的最后一行，而不是整个图像。并且，您不需要在内存中填充数组。为了存储图像，您需要3 *宽度*高度个字符，而不仅仅是3 *宽度+某些内容个字符。@KrzysztofKachniarz @jiggunjer - John Smith
7
我无法评论顶层回答，因为我还没有足够的stackoverflow声望，但我想指出实现中存在一个非常关键的错误。一些位图可以使用负高度编写，因此当您尝试分配图像数据缓冲区时，您的代码将崩溃，并显示std :: bad_alloc。具有负高度的位图意味着图像数据从上到下存储，而不是传统的从下到上。因此，更好的顶级答案版本是（仍然不包括适用于具有不同字节序和大小的系统的可移植性）：
unsigned char* readBMP(char* filename)
{
    int i;
    FILE* f = fopen(filename, "rb");
    unsigned char info[54];
    fread(info, sizeof(unsigned char), 54, f); // read the 54-byte header

    // extract image height and width from header
    int width, height;
    memcpy(&width, info + 18, sizeof(int));
    memcpy(&height, info + 22, sizeof(int));

    int heightSign = 1;
    if (height < 0){
        heightSign = -1;
    }

    int size = 3 * width * abs(height);
    unsigned char* data = new unsigned char[size]; // allocate 3 bytes per pixel
    fread(data, sizeof(unsigned char), size, f); // read the rest of the data at once
    fclose(f);

    if(heightSign == 1){
        for(i = 0; i < size; i += 3)
        {
            //code to flip the image data here....
        }
    }
    return data;
}
6

以下是一个可工作的C ++答案版本：

#include <fstream>
#include <iostream>
#include <string>
#include <array>
#include <vector>
#include <iterator>

std::vector<char> readBMP(const std::string &file)
{
    static constexpr size_t HEADER_SIZE = 54;

    std::ifstream bmp(file, std::ios::binary);

    std::array<char, HEADER_SIZE> header;
    bmp.read(header.data(), header.size());

    auto fileSize = *reinterpret_cast<uint32_t *>(&header[2]);
    auto dataOffset = *reinterpret_cast<uint32_t *>(&header[10]);
    auto width = *reinterpret_cast<uint32_t *>(&header[18]);
    auto height = *reinterpret_cast<uint32_t *>(&header[22]);
    auto depth = *reinterpret_cast<uint16_t *>(&header[28]);

    std::cout << "fileSize: " << fileSize << std::endl;
    std::cout << "dataOffset: " << dataOffset << std::endl;
    std::cout << "width: " << width << std::endl;
    std::cout << "height: " << height << std::endl;
    std::cout << "depth: " << depth << "-bit" << std::endl;

    std::vector<char> img(dataOffset - HEADER_SIZE);
    bmp.read(img.data(), img.size());

    auto dataSize = ((width * 3 + 3) & (~3)) * height;
    img.resize(dataSize);
    bmp.read(img.data(), img.size());

    char temp = 0;

    for (auto i = dataSize - 4; i >= 0; i -= 3)
    {
        temp = img[i];
        img[i] = img[i+2];
        img[i+2] = temp;

        std::cout << "R: " << int(img[i] & 0xff) << " G: " << int(img[i+1] & 0xff) << " B: " << int(img[i+2] & 0xff) << std::endl;
    }

    return img;
}
你在第一个bmp.read中已经到达了流的末尾，难道你不认为第二个bmp.read没有任何作用吗？ - Werner Erasmus
1
非常重要：这会将图像垂直翻转。 - PPP
请问您能告诉我如何修改上述代码以读取.png文件吗？ - user2801184
5
我创建了一个BitMap类，适用于每个像素有24位的bmp文件。如果bmp不兼容，则应该会得到相关错误。
它几乎完全遵循维基百科文章。(唯一的问题是它不能与像素数组偏移大于255的文件一起使用。这在代码中已经注意到并且应该很容易修复。)
我一直在使用这个类来处理由mspaint创建的bmp文件。
下面是一个示例用法。

example.cpp

#include "bmp.h"

int main() {
    // load the file. The constructor now does most of the work
    BitMap example_bmp("examplefile.bmp"); 

    // get the vector <R,G,B> for the pixel at (1,1)
    std::vector<unsigned int> example_vector = example_bmp.getPixel(1,1); 
}

例子向量example_vector现在包含了从图像顶部向下索引为(1,1)的像素的rgb值（以此顺序）。索引从0开始。请参考维基百科的例子。

这是头文件：

#ifndef BMP_H
#define BMP_H

#include <iostream>
#include <vector>
#include <fstream>
class BitMap {

    private:
        unsigned char m_bmpFileHeader[14];
        unsigned int m_pixelArrayOffset;
        unsigned char m_bmpInfoHeader[40];

        int m_height;
        int m_width;
        int m_bitsPerPixel;

        int m_rowSize;
        int m_pixelArraySize;

        unsigned char* m_pixelData;

        char * m_copyname;
        const char * m_filename;
    public:
        BitMap(const char * filename);
        ~BitMap();

        std::vector<unsigned int> getPixel(int i,int j);

        void makeCopy(char * filename);
        void writePixel(int i,int j, int R, int G, int B);

        void swapPixel(int i, int j, int i2, int j2);

        void dispPixelData();

        int width() {return m_width;}
        int height() {return m_height;}

        int vd(int i, int j);
        int hd(int i, int j);

        bool isSorted();
};

BitMap::BitMap( const char * filename) {

    using namespace std;

    m_filename = filename;

    ifstream inf(filename);
    if(!inf) {
        cerr<<"Unable to open file: "<<filename<<"\n";
    }



    //unsigned char m_bmpFileHeader[14];
    unsigned char a;
    for(int i =0;i<14;i++) {
        inf>>hex>>a;
        m_bmpFileHeader[i] = a;
    }
    if(m_bmpFileHeader[0]!='B' || m_bmpFileHeader[1]!='M') {
        cerr<<"Your info header might be different!\nIt should start with 'BM'.\n";
    }

    /*
        THE FOLLOWING LINE ONLY WORKS IF THE OFFSET IS 1 BYTE!!!!! (it can be 4 bytes max)
        That should be fixed now. 
        old line was
        m_pixelArrayOffset = m_bmpFileHeader[10];
    */
    unsigned int * array_offset_ptr = (unsigned int *)(m_bmpFileHeader + 10);
    m_pixelArrayOffset = *array_offset_ptr;


    if( m_bmpFileHeader[11] != 0 || m_bmpFileHeader[12] !=0 || m_bmpFileHeader[13] !=0 ) {
        std::cerr<< "You probably need to fix something. bmp.h("<<__LINE__<<")\n";
    }



    //unsigned char m_bmpInfoHeader[40];
    for(int i=0;i<40;i++) {
        inf>>hex>>a;
        m_bmpInfoHeader[i]=a;
    }

    int * width_ptr = (int*)(m_bmpInfoHeader+4);
    int * height_ptr = (int*)(m_bmpInfoHeader+8);

    m_width = *width_ptr;
    m_height = *height_ptr;

    printf("W: %i, H: %i", m_width, m_height);

    m_bitsPerPixel = m_bmpInfoHeader[14];
    if(m_bitsPerPixel!=24) {
        cerr<<"This program is for 24bpp files. Your bmp is not that\n";
    }
    int compressionMethod = m_bmpInfoHeader[16];
    if(compressionMethod!=0) {
        cerr<<"There's some compression stuff going on that we might not be able to deal with.\n";
        cerr<<"Comment out offending lines to continue anyways. bpm.h line: "<<__LINE__<<"\n";
    }


    m_rowSize = int( floor( (m_bitsPerPixel*m_width + 31.)/32 ) ) *4;
    m_pixelArraySize = m_rowSize* abs(m_height);

    m_pixelData = new unsigned char [m_pixelArraySize];

    inf.seekg(m_pixelArrayOffset,ios::beg);
    for(int i=0;i<m_pixelArraySize;i++) {
        inf>>hex>>a;
        m_pixelData[i]=a; 
    }



}

BitMap::~BitMap() {
    delete[] m_pixelData;
}

void BitMap::dispPixelData() {
    for(int i=0;i<m_pixelArraySize;i++) {
        std::cout<<(unsigned int)m_pixelData[i]<<" ";   
    }
    std::cout<<"\n";
}

// output is in rgb order.
std::vector<unsigned int> BitMap::getPixel(int x, int y) {
    if(x<m_width && y<m_height) {
        std::vector<unsigned int> v;
        v.push_back(0);
        v.push_back(0);
        v.push_back(0);

        y = m_height -1- y; //to flip things
        //std::cout<<"y: "<<y<<" x: "<<x<<"\n";
        v[0] = (unsigned int) ( m_pixelData[ m_rowSize*y+3*x+2 ] ); //red
        v[1] = (unsigned int) ( m_pixelData[ m_rowSize*y+3*x+1 ] ); //greed
        v[2] = (unsigned int) ( m_pixelData[ m_rowSize*y+3*x+0 ] ); //blue


        return v;
    }
    else {std::cerr<<"BAD INDEX\n";std::cerr<<"X: "<<x<<" Y: "<<y<<"\n";}
}

void BitMap::makeCopy(char * filename) {
    std::ofstream copyfile(filename);
    std::ifstream infile(m_filename);
    m_copyname = filename;

    unsigned char c;
    while(infile) {
        infile>>c;
        copyfile<<c;
    }
}

// changes the file
void BitMap::writePixel(int x,int y, int R, int G, int B) {
    std::fstream file(m_filename);
    y = m_height -1- y; // to flip things.
    int blueOffset = m_pixelArrayOffset+m_rowSize*y+3*x+0;

    // writes to the file
    file.seekg(blueOffset,std::ios::beg);
    file<< (unsigned char)B;
    file.seekg(blueOffset+1,std::ios::beg);
    file<< (unsigned char)G;
    file.seekg(blueOffset+2,std::ios::beg);
    file<< (unsigned char)R;

    // edits data in pixelData array 
    m_pixelData[m_rowSize*y+3*x+2] = (unsigned char)R;
    m_pixelData[m_rowSize*y+3*x+1] = (unsigned char)G;
    m_pixelData[m_rowSize*y+3*x+0] = (unsigned char)B;
}

// changes the file
void BitMap::swapPixel(int i, int j, int i2, int j2) {
    std::vector<unsigned int> p1 = (*this).getPixel(i,j);

    std::vector<unsigned int> p2 = (*this).getPixel(i2,j2);

    (*this).writePixel(i,j,p2[0],p2[1],p2[2]);
    (*this).writePixel(i2,j2,p1[0],p1[1],p1[2]);

}
#endif
我喜欢你的方法，但是这种方式不起作用。它没有得到正确的高度和宽度。 - Robben_Ford_Fan_boy
@robben_ford_fan_boy，正确的值是什么？你得到了什么？我记得我曾经广泛使用过它，但这个版本可能存在错误。 - Liam
我认为实际值是1300，而高度和宽度都拉了20。 - Robben_Ford_Fan_boy
1
@Robben_Ford_Fan_boy 好的，你说得对。我之前只是用它来处理小对象（精灵），所以这个问题从未出现过。我会修复它的。 - Liam
好的 - 你改了什么？ - Robben_Ford_Fan_boy
1
@Robben_Ford_Fan_boy 高度和宽度（以及像素数组偏移量）已经为它们保留了4个字节。我最初只使用了一个字节。您可以在当前先前版本的“仅当偏移量为1字节时以下行才有效！！！”部分中查看相关更改。 - Liam
2
我正在使用C/C++，而不是VC ++。感谢您的帮助 :) - Sourav
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接