Image processing 修改RGB图像亮度的算法？

我知道有RGB->亮度的公式，但我需要给定一个亮度参数来修改图像的RGB值。我该怎么做

谢谢

从RGB映射到HSL（色调/饱和度/亮度），保持色调和饱和度相同，只需修改亮度，然后从HSL向后映射到RGB

---

最简单的方法是将R、G、B值乘以某个常数-如果常数大于1，则会使其更亮，如果添加到Mark Ransom的答案中：最好将上述系数与255常数一起使用，并将其添加到当前颜色值中：

float brightnessFac = //between -1.0 and 1.0    
byte brightnessRed = red + (255f * brightnessFac);

如果你只使用一个介于0.0和1.0之间的因子

byte brightnessRed = red * brightnessFac;

---

值0保持为零。

调整图像的亮度是可以完成的最简单的图像处理操作之一。所涉及的全部内容是为每个红色、绿色和蓝色组件添加所需的亮度变化

它会是这样的：

colour = GetPixelColour(x, y)
   newRed   = Truncate(Red(colour)   + brightness)
   newGreen = Truncate(Green(colour) + brightness)
   newBlue  = Truncate(Blue(colour)  + brightness)
   PutPixelColour(x, y) = RGB(newRed, newGreen, newBlue)

编码以确保红色、绿色和蓝色的新值在有效范围内。

Procedure Truncate(value)
      If value < 0 Then value = 0
      If value > 255 Then value = 255
      Return value
   EndProcedure

过程截断（值）
如果值<0，则值=0
如果值>255，则值=255
返回值
结束程序

我的建议与客户的答案相同，但有一点不同：

使用，因为它是一个近似的Photoshop的算法，有更好的结果

---

为了不只是链接到HSP的网站（坦白地说，这应该足够了；只是我不喜欢没有示例的回答），下面是我的

C

实现，它遵循了网站的：

#region Definitions
//Perceived brightness to Red ratio.
private const double Pr = .299;
//Perceived brightness to Green ratio.
private const double Pg = .587;
//Perceived brightness to Blue ratio.
private const double Pb = .114;
#endregion

//Expected ranges: Hue = 0-359... Other values = 0-1
public static ColorRGB ToRGB(double hue, double saturation, double perceivedBrightness, double alpha) {
    //Check values within expected range
    hue = hue < 0 ? 0 : hue > 359 ? 359 : hue;
    saturation = saturation < 0 ? 0 : saturation > 1 ? 1 : saturation;
    perceivedBrightness = perceivedBrightness < 0 ? 0 : perceivedBrightness > 1 ? 1 : perceivedBrightness;
    alpha = alpha < 0 ? 0 : alpha > 1 ? 1 : alpha;
    //Conversion
    var minOverMax = 1 - saturation;
    double r, g, b;
    if (minOverMax > 0) {
        double part;
        if (hue < 0.166666666666667D) { //R>G>B
            hue = 6 * (hue - 0); part = 1 + hue * (1 / minOverMax - 1);
            b = perceivedBrightness / Math.Sqrt(Pr / minOverMax / minOverMax + Pg * part * part + Pb);
            r = b / minOverMax; g = b + hue * (r - b);
        }
        else if (hue < 0.333333333333333D) { //G>R>B
            hue = 6 * (-hue + 0.333333333333333D); part = 1 + hue * (1 / minOverMax - 1);
            b = perceivedBrightness / Math.Sqrt(Pg / minOverMax / minOverMax + Pr * part * part + Pb);
            g = b / minOverMax; r = b + hue * (g - b);
        }
        else if (hue < 0.5D) {   //  G>B>R
            hue = 6 * (hue - 0.333333333333333D); part = 1 + hue * (1 / minOverMax - 1);
            r = perceivedBrightness / Math.Sqrt(Pg / minOverMax / minOverMax + Pb * part * part + Pr);
            g = r / minOverMax; b = r + hue * (g - r);
        }
        else if (hue < 0.666666666666667D) { //B>G>R
            hue = 6 * (-hue + 0.666666666666667D); part = 1 + hue * (1 / minOverMax - 1);
            r = perceivedBrightness / Math.Sqrt(Pb / minOverMax / minOverMax + Pg * part * part + Pr);
            b = r / minOverMax; g = r + hue * (b - r);
        }
        else if (hue < 0.833333333333333D) { //B>R>G
            hue = 6 * (hue - 0.666666666666667D); part = 1 + hue * (1 / minOverMax - 1);
            g = perceivedBrightness / Math.Sqrt(Pb / minOverMax / minOverMax + Pr * part * part + Pg);
            b = g / minOverMax; r = g + hue * (b - g);
        }
        else { //R>B>G
            hue = 6 * (-hue + 1D); part = 1 + hue * (1 / minOverMax - 1);
            g = perceivedBrightness / Math.Sqrt(Pr / minOverMax / minOverMax + Pb * part * part + Pg);
            r = g / minOverMax; b = g + hue * (r - g);
        }
    }
    else {
        if (hue < 0.166666666666667D) { //R>G>B
            hue = 6 * (hue - 0D); r = Math.Sqrt(perceivedBrightness * perceivedBrightness / (Pr + Pg * hue * hue)); g = r * hue; b = 0;
        }
        else if (hue < 0.333333333333333D) { //G>R>B
            hue = 6 * (-hue + 0.333333333333333D); g = Math.Sqrt(perceivedBrightness * perceivedBrightness / (Pg + Pr * hue * hue)); r = g * hue; b = 0;
        }
        else if (hue < 0.5D) { //G>B>R
            hue = 6 * (hue - 0.333333333333333D); g = Math.Sqrt(perceivedBrightness * perceivedBrightness / (Pg + Pb * hue * hue)); b = g * hue; r = 0;
        }
        else if (hue < 0.666666666666667D) { //B>G>R
            hue = 6 * (-hue + 0.666666666666667D); b = Math.Sqrt(perceivedBrightness * perceivedBrightness / (Pb + Pg * hue * hue)); g = b * hue; r = 0;
        }
        else if (hue < 0.833333333333333D) { //B>R>G
            hue = 6 * (hue - 0.666666666666667D); b = Math.Sqrt(perceivedBrightness * perceivedBrightness / (Pb + Pr * hue * hue)); r = b * hue; g = 0;
        }
        else { //R>B>G
            hue = 6 * (-hue + 1D); r = Math.Sqrt(perceivedBrightness * perceivedBrightness / (Pr + Pb * hue * hue)); b = r * hue; g = 0;
        }
    }
    return new ColorRGB(r, g, b, alpha);
}

//Expected ranges: 0-1 on all components
public static ColorHSP FromRGB(double red, double green, double blue, double alpha) {
    //Guarantee RGB values are in the correct ranges
    red = red < 0 ? 0 : red > 1 ? 1 : red;
    green = green < 0 ? 0 : green > 1 ? 1 : green;
    blue = blue < 0 ? 0 : blue > 1 ? 1 : blue;
    alpha = alpha < 0 ? 0 : alpha > 1 ? 1 : alpha;
    //Prepare & cache values for conversion
    var max = MathExtensions.Max(red, green, blue);
    var min = MathExtensions.Min(red, green, blue);
    var delta = max - min;
    double h, s, p = Math.Sqrt(0.299 * red + 0.587 * green + 0.114 * blue);
    //Conversion
    if (delta.Equals(0)) h = 0;
    else if (max.Equals(red)) {
        h = (green - blue) / delta % 6;
    }
    else if (max.Equals(green)) h = (blue - red) / delta + 2;
    else h = (red - green) / delta + 4;
    h *= 60;
    if (h < 0) h += 360;
    if (p.Equals(0))
        s = 0;
    else
        s = delta / p;
    //Result
    return new ColorHSP(h, s, p, alpha);
}

#区域定义
//感知亮度与红色的比率。
私人常数双Pr=.299；
//感知亮度与绿色比率。
私人常数双Pg=.587；
//感知亮度与蓝色的比率。
私有常量双Pb=.114；
#端区
//预期范围：色调=0-359。。。其他值=0-1
公共静态颜色RGB ToRGB（双色调、双饱和度、双感知亮度、双alpha）{
//检查预期范围内的值
色调=色调<0？0：色调>359？359：色调；
饱和度=饱和度<0？0：饱和度>1？1：饱和度；
感知亮度=感知亮度<0？0：感知亮度>1？1：感知亮度；
α=α<0？0：α>1？1：α；
//转化
var minOverMax=1-饱和；
双r，g，b；
如果（最小最大值>0）{
两部分；
如果（色调<0.16667d）{//R>G>B
色调=6*（色调-0）；部分=1+色调*（1/最小值最大值-1）；
b=感知亮度/数学Sqrt（Pr/minOverMax/minOverMax+Pg*零件*零件+Pb）；
r=b/最小最大值；g=b+色调*（r-b）；
}
else如果（色调<0.333d）{//G>R>B
色调=6*（-hue+0.333d）；部分=1+hue*（1/minOverMax-1）；
b=感知亮度/数学Sqrt（Pg/minOverMax/minOverMax+Pr*零件*零件+Pb）；
g=b/最小最大值；r=b+色调*（g-b）；
}
如果（色调<0.5D）{//G>B>R
色调=6*（色调-0.333D）；部分=1+色调*（1/最小值最大值-1）；
r=感知亮度/数学Sqrt（Pg/minOverMax/minOverMax+Pb*零件*零件+Pr）；
g=r/minOverMax；b=r+hue*（g-r）；
}
else如果（色调<0.6666667d）{//B>G>R
色调=6*（-色调+0.6666667D）；部分=1+色调*（1/最小值最大值-1）；
r=感知亮度/数学Sqrt（Pb/minOverMax/minOverMax+Pg*零件*零件+Pr）；
b=r/minOverMax；g=r+hue*（b-r）；
}
else如果（色调<0.833333d）{//B>R>G
色调=6*（色调-0.666666667D）；部分=1+色调*（1/最小值最大值-1）；
g=感知亮度/数学Sqrt（Pb/minOverMax/minOverMax+Pr*零件*零件+Pg）；
b=g/minOverMax；r=g+hue*（b-g）；
}
else{//R>B>G
色调=6*（-hue+1D）；部分=1+hue*（1/minOverMax-1）；
g=感知亮度/数学Sqrt（Pr/minOverMax/minOverMax+Pb*零件*零件+Pg）；
r=g/minOverMax；b=g+hue*（r-g）；
}
}
否则{
如果（色调<0.16667d）{//R>G>B
色调=6*（色调-0D）；r=Math.Sqrt（感知亮度*感知亮度/（Pr+Pg*色调*色调））；g=r*色调；b=0；
}
else如果（色调<0.333d）{//G>R>B
色调=6*（-hue+0.333d）；g=Math.Sqrt（感知亮度*感知亮度/（Pg+Pr*色调*色调））；r=g*色调；b=0；
}
如果（色调<0.5D）{//G>B>R
色调=6*（色调-0.333d）；g=Math.Sqrt（感知亮度*感知亮度/（Pg+Pb*色调*色调））；b=g*色调；r=0；
}
else如果（色调<0.6666667d）{//B>G>R
色调=6*（-hue+0.666666667d）；b=Math.Sqrt（感知亮度*感知亮度/（Pb+Pg*色调*色调））；g=b*色调；r=0；
}
else如果（色调<0.833333d）{//B>R>G
色调=6*（色调-0.666666667d）；b=Math.Sqrt（感知亮度*感知亮度/（Pb+Pr*色调*色调））；r=b*色调；g=0；
}
else{//R>B>G
色调=6*（-hue+1D）；r=Math.Sqrt（感知亮度*感知亮度/（Pr+Pb*色调*色调））；b=r*色调；g=0；
}
}
返回新的颜色RGB（r、g、b、alpha）；
}
//预期范围：所有组件上的0-1
RGB的公共静态颜色HSP（双红、双绿、双蓝、双阿尔法）{
//保证RGB值在正确的范围内
红色=红色<0？0：红色>1？1：红色；
绿色=绿色<0？0：绿色>1？1：绿色；
蓝色=蓝色<0？0：蓝色>1？1：蓝色；
α=α<0？0：α>1？1：α；
//准备和cac
import java.io. * ;
import java.awt.Color;
import javax.imageio.ImageIO;
import java.io. * ;
import java.awt.image.BufferedImage;

class Psp {

    public static void main(String a[]) {
        try {

            File input = new File("abc.jpg");
            File output = new File("output1.jpg");
            BufferedImage picture1 = ImageIO.read(input); // original
            BufferedImage picture2 = new BufferedImage(picture1.getWidth(), picture1.getHeight(), BufferedImage.TYPE_INT_RGB);
            int width = picture1.getWidth();
            int height = picture1.getHeight();

            int factor = 50;
            for (int y = 0; y < height; y++) { //loops for images
                for (int x = 0; x < width; x++) {

                    Color c = new Color(picture1.getRGB(x, y));
                    int r = c.getRed() + factor;
                    int b = c.getBlue() + factor;
                    int g = c.getGreen() + factor;

                    if (r >= 256) {
                        r = 255;
                    } else if (r < 0) {
                        r = 0;
                    }

                    if (g >= 256) {
                        g = 255;
                    } else if (g < 0) {
                        g = 0;
                    }

                    if (b >= 256) {
                        b = 255;
                    } else if (b < 0) {
                        b = 0;
                    }
                    picture2.setRGB(x, y, new Color(r, g, b).getRGB());

                }
            }

            ImageIO.write(picture2, "jpg", output);
        } catch(Exception e) {
            System.out.println(e);
        }

    }

}