Question

我正尝试通过以下步骤对P6 PPM格式的图像进行像素化：

读取4x4网格中的PPM图像
找到每个4x4网格的RGB平均颜色值
写入新文件。

PPM文件以以下格式开始：

P6 
# ignores comments in header 
width 
height 
max colour value

我的问题： 输出的PPM图像文件（我正在使用GIMP图像编辑器打开，也可以在任何文本编辑器（如“记事本”）中打开以查看原始数据）由一个纯色块组成，而实际上它应类似于一种马赛克。

注意：4x4网格可以变化，即网格尺寸的值越大，输出图像的像素化就越多。我的代码主要受到另一个堆栈溢出问题的影响，在该问题中，用户尝试了C＃中的类似实现。此问题的链接： https://codereview.stackexchange.com/questions/140162/pixelate-image-with-average-cell-color

更新：现在，输出似乎将图像的前1/5像素化，但是输出图像的其余部分仍然是一个色块。我认为我的问题在于我将细胞视为线性顺序的像素。

我的尝试：

#include <stdio.h>
#include <assert.h>

//Struct to store RGB values 
typedef struct {
    unsigned char r, g, b;
} pixel;

int main()
{
    int y, x;               //Loop iteration variables
    int yy = 0;             //Loop iteration variables
    int xx = 0;             //Loop iteration variables
    char magic_number[10];  //Variable which reads P6 in the header 
    int w, h, m;            //Image dimension variables
    pixel currentPix;       //Current pixel variable 
    int avR;                //Red declaration
    int avG;                //Green declaration 
    int avB;                //Blue declarataion 
    int total;              //Loop iteration counter declaration 

    //Input file 
    FILE* f;
    f = fopen("Dog2048x2048.ppm", "r"); //Read PPM file 
    if (f == NULL)                      //Error notifiaction if file cannot be found 
    {
        fprintf(stderr, "ERROR: cannot open input file");
        getchar();
        exit(1);
    }
    //Scan the header of the PPM file to get the magic number (P6), width
    //height and max colour value 
    fscanf(f, "%s %d %d %d", &magic_number, &w, &h, &m);

    //initialize file for writing (open and header)
    FILE* f_output;
    f_output = fopen("some_file.ppm", "w");
    //fprintf(f_output, "%s %d %d %d", magic_number, w, h, m);
    fprintf(f_output, "P6\n%d %d\n255\n", w, h);
    if (f_output == NULL)                       //Error notifiaction if file cannot be found 
    {
        fprintf(stderr, "ERROR: cannot open output file");
        getchar();
        exit(1);
    }

    // Loop through the image in 4x4 cells.
    for (int yy = 0; yy < h && yy < h; yy += 4)
    {
        for (int xx = 0; xx < w && xx < w; xx += 4)
        {
            avR = 0;
            avG = 0;
            avB = 0;
            total = 0;

            // Store each color from the 4x4 cell into cellColors.
            for (int y = yy; y < yy + 4 && y < h; y++)
            {
                for (int x = xx; x < xx + 4 && x < w; x++)
                {
                    //Reads input file stream 
                    fread(&currentPix, 3, 1, f);

                    //Current pixels 
                    avR += currentPix.r;
                    avG += currentPix.g;
                    avB += currentPix.b;

                    //Counts loop iterations for later use in colour averaging
                    total++;

                }
            }
            //Average RGB values
            avR /= total; 
            avG /= total;
            avB /= total;

            // Go BACK over the 4x4 cell and set each pixel to the average color.
            for (int y = yy; y < yy + 4 && y < h; y++)
            {
                for (int x = xx; x < xx + 4 && x < w; x++)
                {
                    //Print out to new file 
                    fprintf(f_output, "%i %i %i\t", avR, avG, avB);
                }
            }
        }
        fprintf(f_output, "\n");
    }
    return 0;
}

Answer 1

您的主要错误是您假设正在读写4×4像素块，而实际上却是线性访问像素数据。您的怀疑是正确的。

请考虑以下示例。假设有一个12×4 1通道图像：

01 02 03 04 05 06 07 08 09 10 11 12
13 14 15 16 17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32 33 34 35 36
37 38 39 40 41 42 43 44 45 46 47 48

每个像素的颜色等于其在PPM文件中的位置。

现在这些是您在像素化第一个4×4块时希望读取的像素：

01 02 03 04
13 14 15 16
25 26 27 28
37 38 39 40

这些是依次执行fread()实际读取的像素：

01 02 03 04 05 06 07 08 09 10 11 12
13 14 15 16

因此，最终您将输入图像视为如下所示：

01 02 03 04 05 06 07 08 09 10 11 12
13 14 15 16                                 01 02 03 04   17 18 19 20   33 34 35 36
            17 18 19 20 21 22 23 24   -->   05 06 07 08   21 22 23 24   37 38 39 40
25 26 27 28 29 30 31 32                     09 10 11 12   25 26 27 28   41 42 43 44
                        33 34 35 36         13 14 15 16   29 30 31 32   45 46 47 48
37 38 39 40 41 42 43 44 45 46 47 48

代替：

01 02 03 04   05 06 07 08   09 10 11 12
13 14 15 16   17 18 19 20   21 22 23 24
25 26 27 28   29 30 31 32   33 34 35 36
37 38 39 40   41 42 43 44   45 46 47 48

解决此问题的较简单方法之一是分配一个要在其中读取数据的数组。一旦该数组中充满了数据，就可以以任何顺序访问其元素，而不是严格按照线性顺序fread()暗示。

如何像素化图像

1 个答案: