从文件中读取模式并在 C 中创建该模式的 bmp 图像答案

【问题标题】：Reading pattern from file and create a bmp image of that in C从文件中读取模式并在 C 中创建该模式的 bmp 图像
【发布时间】：2016-09-22 12:59:06
【问题描述】：

我想使用 C 语言读取一个文本文件。这是文件：-

您会看到文件的文本内容中有一些模式。 0 表示什么都没有。 9 表示黑色。所以有从 0 到 9 的配色方案。

我必须为此创建一个位图图像，并且颜色取决于图案中的值。您必须使用 0-256 配色方案对其进行调整。最终输出如下所示

现在看到文本文件内容中的图案与最终输出的位图文件相反（不是必需的）。位图图像中颜色的深浅取决于文本内容模式中的值。

谁能告诉我我是如何用 C 语言实现的。

我可以创建 BMP 文件，但不是根据文本文件中的模式。

#include <stdio.h>
#include <stdlib.h>

int main()
{

char bitmap[1900];

    // -- FILE HEADER -- //

    // bitmap signature
    bitmap[0] = 0x42;
    bitmap[1] = 0x4d;

    // file size
    bitmap[2] = 58; // 40 + 14 + 12
    bitmap[3] = 0;
    bitmap[4] = 0;
    bitmap[5] = 0;
    int i=0;
    // reserved field (in hex. 00 00 00 00)
    for(i = 6; i < 10; i++) bitmap[i] = 0;

    // offset of pixel data inside the image
    for(i = 10; i < 14; i++) bitmap[i] = 0;

    // -- BITMAP HEADER -- //

    // header size
    bitmap[14] = 40;
    for(i = 15; i < 18; i++) bitmap[i] = 0;

    // width of the image
    bitmap[18] = 4;
    for(i = 19; i < 22; i++) bitmap[i] = 0;

    // height of the image
    bitmap[22] = 1;
    for(i = 23; i < 26; i++) bitmap[i] = 0;

    // reserved field
    bitmap[26] = 1;
    bitmap[27] = 0;

    // number of bits per pixel
    bitmap[28] = 24; // 3 byte
    bitmap[29] = 0;

    // compression method (no compression here)
    for(i = 30; i < 34; i++) bitmap[i] = 0;

    // size of pixel data
    bitmap[34] = 12; // 12 bits => 4 pixels
    bitmap[35] = 0;
    bitmap[36] = 0;
    bitmap[37] = 0;

    // horizontal resolution of the image - pixels per meter (2835)
    bitmap[38] = 0;
    bitmap[39] = 0;
    bitmap[40] = 0b00110000;
    bitmap[41] = 0b10110001;

    // vertical resolution of the image - pixels per meter (2835)
    bitmap[42] = 0;
    bitmap[43] = 0;
    bitmap[44] = 0b00110000;
    bitmap[45] = 0b10110001;

    // color pallette information
    for(i = 46; i < 50; i++) bitmap[i] = 0;

    // number of important colors
    for(i = 50; i < 54; i++) bitmap[i] = 0;

    // -- PIXEL DATA -- //
    for(i = 54; i < 66; i++) bitmap[i] = 255;


    FILE *file;
    file = fopen("bitmap.bmp", "w+");
    for(i = 0; i < 66; i++)
    {
        fputc(bitmap[i], file);
    }
    fclose(file);
    return 0;
}

【问题讨论】：

这么多神奇的数字...为了您自己的理智，请使用命名常量！
请使用unsigned char bitmap[1900].
为什么在需要 24x15 的情况下制作 4x1 位图？您需要在数组中的每个位置写入 3 个字节（对于灰度每个字节都相同）像素数据，（实际上）是 array[height][width][3]。
是不是因为图像大小信息大于标头的 1 个字节可以容纳？该字段是uint32_t。
unsigned imagesize = height * width * 3; for(int i=0; i<4; i++) { bitmap[34+i] = imagesize & 255; imagesize >>= 8; }。还要注意，只有当图像宽度是 4 的倍数（在这种情况下）时，数组宽度才等于图像宽度，因为数组宽度（它的“步幅”）本身必须始终是 4 的倍数。跨度>

标签： c image-processing bitmap

【解决方案1】：

这是一个工作代码。我不检查某些错误情况（例如，输入文件格式错误）。我放了一些注释，虽然代码本身并不难理解。

#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include <errno.h>
#include <ctype.h>

#define BMP_ASSERT(condition, message) \
    do { \
        if (! (condition)) { \
            fprintf(stderr, __FILE__ ":%d: %s: Assertion `" #condition \
                "` failed.\n\t: %s\n", __LINE__, __func__, message); \
            exit(EXIT_FAILURE); \
        } \
    } while (false)

#define BMP_COLORMAP_SIZE   10

////////////////////////////////////////////////////////////////////////////////
// STRUCTS

typedef struct __attribute__((__packed__))
bmp_color 
{
    uint8_t             r,
                        g,
                        b;
    uint8_t             :8;
}                       bmp_color_t;

typedef struct __attribute__((__packed__))
bmp_header_infos
{
    uint32_t const      info_size;
    uint32_t            width;
    uint32_t            height;
    uint16_t const      planes;
    uint16_t const      bpp;
    uint32_t const      compression;
    uint32_t            img_size;
    uint32_t const      horz_resolution;
    uint32_t const      vert_resolution;
    uint32_t const      n_colors;
    uint32_t const      n_important_colors;
}                       bmp_header_infos_t;

typedef struct __attribute__((__packed__))
bmp_header
{
    /* Header */
    char const          signature[2];
    uint32_t            file_size;
    uint32_t const      :32; // reserved
    uint32_t const      img_offset;
    /* Infos */
    bmp_header_infos_t  infos;
    /* Color map */
    bmp_color_t         colormap[BMP_COLORMAP_SIZE];
}                       bmp_header_t;

typedef struct          bmp_file_datas
{
    size_t              width;
    size_t              height;
    /* Bit map */
    uint8_t             *bitmap;
}                       bmp_file_datas_t;


////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS

/* Give a header with the right magic values */
bmp_header_t *
bmp_get_header(void)
{
    static bmp_header_t _header = {
        {'B', 'M'},
        0u,
        sizeof(_header),
        {   // struct info
            sizeof(_header.infos),
            0u, 0u, // width, height
            1u,     // planes
            8u,     // bpp
            0u,     // no compression
            0u,     // img size
            0u, 0u, // resolution
            BMP_COLORMAP_SIZE,
            BMP_COLORMAP_SIZE,      // important colors
        },
        {{0u}}
    };
    bmp_header_t        *header = malloc(sizeof(_header));
    size_t              i,
                        color;

    assert(header != NULL);
    memcpy(header, &_header, sizeof(*header));
    // setting the scale of greys
    for (i = 0 ; i < BMP_COLORMAP_SIZE ; ++i)
    {
        color = (i * 255) / BMP_COLORMAP_SIZE;
        header->colormap[i] = (bmp_color_t){color, color, color};
    }
    return header;
}

/* Take all the file content and store it in a buffer */
char *
get_file_content(char const *filename)
{
    FILE        *file_handler = fopen(filename, "r");
    size_t      file_len;
    char        *buff;

    BMP_ASSERT(file_handler != NULL, strerror(errno));
    fseek(file_handler, 0, SEEK_END);
    file_len = ftell(file_handler);
    fseek(file_handler, 0, SEEK_SET);
    buff = malloc(file_len + 1);
    assert(buff != NULL);
    fread(buff, file_len, 1, file_handler);
    buff[file_len] = '\0';
    fclose(file_handler);
    return buff;
}

/* Get the greatest multiple of 4 that is >= size */
static inline size_t
multiple_of_four(size_t size)
{
    while (size % 4)
        ++size;
    return size;
}

/* Get the informations from buffer: size of line, number of lines */
void
get_file_infos(char *buff, bmp_header_t *header, bmp_file_datas_t *datas)
{
    /* width & height */
    header->infos.width =  strchr(buff, '\n') - buff;
    header->infos.height = strlen(buff) / (header->infos.width + 1);
                                            // + 1 for the terminating '\n'
    datas->width = multiple_of_four(header->infos.width);
    datas->height = header->infos.height;
printf("File size: %u, %u\n", header->infos.width, header->infos.height);
    /* image size & bitmap allocation */
    header->infos.img_size = datas->width * datas->height;
    datas->bitmap = malloc(header->infos.img_size * sizeof(*datas->bitmap));
    assert(datas->bitmap != NULL);
    header->file_size = header->img_offset + header->infos.img_size;
}

/* Take the informations from the buffer and store them in the bitmap */
void
write_bitmap(char *buff, bmp_file_datas_t *datas)
{
    size_t          ibuff,
                    iline = 0,
                    ibitmap = 0;

    for (ibuff = 0 ; buff[ibuff] ; ++ibuff)
    {
        if (isdigit(buff[ibuff]))
        {
            datas->bitmap[ibitmap] = BMP_COLORMAP_SIZE - 1 - (buff[ibuff] - '0');
            ++ibitmap;
        }
        else if (buff[ibuff] == '\n')
        {
            ++iline;
            ibitmap = iline * datas->width;
        }
    }
}

/* Write the datas in the file: the header and the bitmap */
void
write_in_file(bmp_header_t *header,
              bmp_file_datas_t *datas,
              char const *filename)
{
    FILE        *file_handler = fopen(filename, "w");

    BMP_ASSERT(file_handler != NULL, strerror(errno));
    fwrite(header, sizeof(*header), 1, file_handler);
    fwrite(datas->bitmap, header->infos.img_size, 1, file_handler);
    fclose(file_handler);
}


int main(int argc, char **argv)
{
    char                *buff;
    bmp_header_t        *header;
    bmp_file_datas_t    datas;

    if (argc != 3)
    {
        fprintf(stderr, "Usage: %s <input filename> <output filename>\n",
                                argv[0]);
        return EXIT_FAILURE;
    }
    buff = get_file_content(argv[1]);
    header = bmp_get_header();
    get_file_infos(buff, header, &datas);
    write_bitmap(buff, &datas);
    write_in_file(header, &datas, argv[2]);
    free(buff), free(header), free(datas.bitmap);
    return EXIT_SUCCESS;
}

【讨论】：

我认为代码不起作用。因为首先存在从 void 到 uint32 或其他的转换错误。第二次删除这些错误后，不会生成文件。你能检查一下吗。 ?
它可以在我的 Debian 上与 gcc -std=c11 -Wall -Wextra -pedantic 一起正常工作（gcc-5 和 gcc-6）。所以其他标准编译器应该没问题。请更具体地说明错误。
你还对它感兴趣吗？你没有回答我的问题：你遇到了什么样的错误？没有详细信息，我无能为力。
@MuhammadHashimShafiq 我猜你是用 C++ 编译器编译的，因为这是一个 C++ 错误。 C 接受从 void * 到每个指针类型的隐式转换。用C编译器编译C，会更好。
@MuhammadHashimShafiq 如果你做 C++ 代码，请将 C 标签替换为 C++ 标签。

【解决方案2】：

实现所需功能的粗略方法是：（不是真正的 C，但这是你的作业，不是我的）

WIDTH = 0, HEIGHT = 0
if(LINE=READ_LINE(fin))
  WIDTH = strlen(LINE)
  ++HEIGHT
else
  ERROR!!!
PUSH(LINE)
while(LINE=READ_LINE(fin))
  if(WIDTH != strlen(LINE))
    ERROR!!!
  else
    ++HEIGHT
    PUSH(LINE)
WRITE_BMP_HEADER(WIDTH, HEIGHT)
for(h = 0; h < HEIGHT; ++h)
  LINE = POP()
  for(w = 0; w < WIDTH; ++w)
    COLOR = (LINE[w] - '0') * 255 / 9;
    WRITE_BMP_COLOR(COLOR)
  WRITE_BMP_PADDING(W)

【讨论】：