Question

我正在研究一个名为filter（不舒服，第4周）的CS50程序，它必须将图像从正常图像传输到棕褐色。除非必须转移白色，否则它工作正常。尝试转移白色时，它只是将其转换为蓝色和绿色。像这样：

原始

SEPIA

如您所见，除了白色或接近白色外，它可以将所有内容都转换为精细。这是我的代码（仅适用于棕褐色部分）：


void sepia(int height, int width, RGBTRIPLE image[height][width])
{
    for(int j = 0; j < width; j++)
    {
       for (int i = 0; i < height; i++)
       {
           int sepiared =  image[i][j].rgbtRed *.393  +   image[i][j].rgbtGreen *.769 +  image[i][j].rgbtBlue *.189;
           int sepiagreen =  image[i][j].rgbtRed *.349  +  image[i][j].rgbtGreen *.686 +  image[i][j].rgbtBlue *.168;
            int sepiablue =  image[i][j].rgbtRed *.272  +   image[i][j].rgbtGreen *.534 +  image[i][j].rgbtBlue *.131;
           image[i][j].rgbtRed = sepiared;
           image[i][j].rgbtGreen = sepiagreen;
           image[i][j].rgbtBlue = sepiablue;
       }
    }

    return;
}

请帮助我理解为什么会这样。 Clang不打印任何错误消息。

您的确是，代码丢失：）

Answer 1

您需要使用“饱和度数学”。

对于近白色，您的中间值（例如sepiared）可以超过255。

255（0xFF）是unsigned char可以容纳的最大值

例如，如果sepiared为256（0x100），则将其放入rgbtRed时，将仅保留最右边的8位，并且该值将被截断设为0。因此，您将得到一个非常暗的值[接近黑色]，而不是一个非常明亮的值[接近白色]。

要解决此问题，请添加：

if (sepiared > 255)
    sepiared = 255;

另外，请注意for循环的顺序，它的缓存效率非常低。

而且，在任何地方使用image[i][j].whatever是浪费[并且可能很慢]。最好使用指向当前像素的指针。

无论如何，这是您的代码的更新版本，其中包含以下更改：

void
sepia(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE *pix;

    for (int i = 0; i < height; i++) {
        pix = &image[i][0];
        for (int j = 0; j < width; j++, pix++) {
            int sepiared = pix->rgbtRed * .393 +
                pix->rgbtGreen * .769 +
                pix->rgbtBlue * .189;
            int sepiagreen = pix->rgbtRed * .349 +
                pix->rgbtGreen * .686 +
                pix->rgbtBlue * .168;
            int sepiablue = pix->rgbtRed * .272 +
                pix->rgbtGreen * .534 +
                pix->rgbtBlue * .131;

            if (sepiared > 255)
                sepiared = 255;
            if (sepiagreen > 255)
                sepiagreen = 255;
            if (sepiablue > 255)
                sepiablue = 255;

            pix->rgbtRed = sepiared;
            pix->rgbtGreen = sepiagreen;
            pix->rgbtBlue = sepiablue;
        }
    }
}

此外，请注意在像素图像上使用浮点数学运算可能会有点慢。在这种情况下，使用缩放整数数学会更快/更好。

这是执行此操作的版本：

void
sepia(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE *pix;

    for (int i = 0; i < height; i++) {
        pix = &image[i][0];
        for (int j = 0; j < width; j++, pix++) {
            int sepiared = pix->rgbtRed * 393 +
                pix->rgbtGreen * 769 +
                pix->rgbtBlue * 189;
            int sepiagreen = pix->rgbtRed * 349 +
                pix->rgbtGreen * 686 +
                pix->rgbtBlue * 168;
            int sepiablue = pix->rgbtRed * 272 +
                pix->rgbtGreen * 534 +
                pix->rgbtBlue * 131;

            sepiared /= 1000;
            sepiagreen /= 1000;
            sepiablue /= 1000;

            if (sepiared > 255)
                sepiared = 255;
            if (sepiagreen > 255)
                sepiagreen = 255;
            if (sepiablue > 255)
                sepiablue = 255;

            pix->rgbtRed = sepiared;
            pix->rgbtGreen = sepiagreen;
            pix->rgbtBlue = sepiablue;
        }
    }
}

Answer 2

所以您需要认真编辑代码

将原始图像暂时存储一段时间


            originalBlue = image[i][j].rgbtBlue;
            originalRed = image[i][j].rgbtRed;
            originalGreen = image[i][j].rgbtGreen;

每个公式的结果都可能不是整数，因此请使用float并将其四舍五入到最接近的整数

            sepiaRed = round(.393 * originalRed + .769 * originalGreen + .189 * originalBlue);
            sepiaGreen = round(.349 * originalRed + .686 * originalGreen + .168 * originalBlue);
            sepiaBlue = round(.272 * originalRed + .534 * originalGreen + .131 * originalBlue);

            if (sepiaRed > 255)
            {
                sepiaRed = 255;
            }

            if (sepiaGreen > 255)
            {
                sepiaGreen = 255;
            }

            if (sepiaBlue > 255)
            {
                sepiaBlue = 255;
            }

现在将值存储为原始值

            image[i][j].rgbtBlue = sepiaBlue;
            image[i][j].rgbtRed = sepiaRed;
            image[i][j].rgbtGreen = sepiaGreen;

在循环外声明所有变量

    float sepiaRed;
    float sepiaBlue;
    float sepiaGreen;
    int originalRed;
    int originalBlue;
    int originalGreen;

希望对您有帮助

Answer 3

首先，顺便说一句，当您遇到CS50问题时，请先在StackOverflow中搜索关键字。答案可能在那里。如果您搜索sepia RGBTRIPLE cs50，您将获得很多匹配。

经过大量像素处理后，您将磨练一些有用的调试直观知识。其中：

如果看到对角线偏移，则图像的每行字节数可能大于宽度乘以像素大小。（尤其是在YCbCr图像中或在图像缓冲区与128位向量大小对齐的平台上。）
2倍或0.5倍的图像显示可能意味着您没有注意视网膜显示屏上的比例值。
某些色彩空间错误将立即向您指出BGR与RGB字节排序问题。根本没有蓝色通道或全部没有蓝色通道？可能将ARGB与BGRA混合。

更重要的是：

如果您在明亮或色彩饱和的区域看到不整洁的图像，则您的像素分量值可能会过饱和（超过最大值，并丢掉高位）。

每次（1）将颜色分量乘以大于1的数字或（2）每次将多个颜色分量相加时，都需要考虑如果超过最大值会发生什么。如果您的中级数学将添加两个值然后除以2，请确保您的编译操作将使用足够大的变量大小来容纳该额外位。

因此，在您的内部循环中，当操作白色像素时，几乎每个颜色分量都将超过255（即红色和绿色将超过，但蓝色不会超过，因为棕褐色的蓝色较低）：

int sepiared =  image[i][j].rgbtRed *.393  +   image[i][j].rgbtGreen *.769 +  image[i][j].rgbtBlue *.189;
int sepiagreen =  image[i][j].rgbtRed *.349  +  image[i][j].rgbtGreen *.686 +  image[i][j].rgbtBlue *.168;
int sepiablue =  image[i][j].rgbtRed *.272  +   image[i][j].rgbtGreen *.534 +  image[i][j].rgbtBlue *.131;

结果值为{255，255，255} x {.393 + .769 + .189，.349 + .686 + .168，.272 + .534 + .131}或{344.5，306.8 ，238.9}。

但是因为在RGBTRIPLE结构的BYTE组件中没有足够的位容纳那些值，所以您的值将是错误的。因此，您可以执行以下操作：

int sepiared =  (int) image[i][j].rgbtRed *.393  +   image[i][j].rgbtGreen *.769 +  image[i][j].rgbtBlue *.189;
int sepiagreen =  (int) image[i][j].rgbtRed *.349  +  image[i][j].rgbtGreen *.686 +  image[i][j].rgbtBlue *.168;
int sepiablue =  (int) image[i][j].rgbtRed *.272  +   image[i][j].rgbtGreen *.534 +  image[i][j].rgbtBlue *.131;
sepiared = min(sepiared, 255);
sepiagreen = min(sepiagreen, 255);
sepiablue = min(sepiablue, 255);

请注意，我进行了两项更改：

将每个表达式中的第一个值转换为（int）;否则，计算将以字节为单位，您将丢失高位。
在每个像素组件上强制使用最大值255。

在考虑其他答案时，请添加我的第一个修正。如果您已经放弃高位，则最多检查255个值将无济于事！

CS50棕褐色问题，将图像从正常状态转换为棕褐色

3 个答案: