Algoritmo para conmutar entre RGB y HSB Valores de Color
https://stackoverflow.com/questions/4123998
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
leí el artículo Algoritmo para cambiar entre RGB y los valores HSB color
Type RGBColor
Red As Byte
Green As Byte
Blue As Byte
End Type
Type HSBColor
Hue As Double
Saturation As Double
Brightness As Double
End Type
Function RGBToHSB(rgb As RGBColor) As HSBColor
Dim minRGB, maxRGB, Delta As Double
Dim h, s, b As Double
h = 0
minRGB = Min(Min(rgb.Red, rgb.Green), rgb.Blue)
maxRGB = Max(Max(rgb.Red, rgb.Green), rgb.Blue)
Delta = (maxRGB - minRGB)
b = maxRGB
If (maxRGB <> 0) Then
s = 255 * Delta / maxRGB
Else
s = 0
End If
If (s <> 0) Then
If rgb.Red = maxRGB Then
h = (CDbl(rgb.Green) - CDbl(rgb.Blue)) / Delta
Else
If rgb.Green = maxRGB Then
h = 2 + (CDbl(rgb.Blue) - CDbl(rgb.Red)) / Delta
Else
If rgb.Blue = maxRGB Then
h = 4 + (CDbl(rgb.Red) - CDbl(rgb.Green)) / Delta
End If
End If
End If
Else
h = -1
End If
h = h * 60
If h < 0 Then h = h + 360
RGBToHSB.Hue = h
RGBToHSB.Saturation = s * 100 / 255
RGBToHSB.Brightness = b * 100 / 255
End Function
Function HSBToRGB(hsb As HSBColor) As RGBColor
Dim maxRGB, Delta As Double
Dim h, s, b As Double
h = hsb.Hue / 60
s = hsb.Saturation * 255 / 100
b = hsb.Brightness * 255 / 100
maxRGB = b
If s = 0 Then
HSBToRGB.Red = 0
HSBToRGB.Green = 0
HSBToRGB.Blue = 0
Else
Delta = s * maxRGB / 255
If h > 3 Then
HSBToRGB.Blue = CByte(Round(maxRGB))
If h > 4 Then
HSBToRGB.Green = CByte(Round(maxRGB - Delta))
HSBToRGB.Red = CByte(Round((h - 4) * Delta)) + HSBToRGB.Green
Else
HSBToRGB.Red = CByte(Round(maxRGB - Delta))
HSBToRGB.Green = CByte(HSBToRGB.Red - Round((h - 4) * Delta))
End If
Else
If h > 1 Then
HSBToRGB.Green = CByte(Round(maxRGB))
If h > 2 Then
HSBToRGB.Red = CByte(Round(maxRGB - Delta))
HSBToRGB.Blue = CByte(Round((h - 2) * Delta)) + HSBToRGB.Red
Else
HSBToRGB.Blue = CByte(Round(maxRGB - Delta))
HSBToRGB.Red = CByte(HSBToRGB.Blue - Round((h - 2) * Delta))
End If
Else
If h > -1 Then
HSBToRGB.Red = CByte(Round(maxRGB))
If h > 0 Then
HSBToRGB.Blue = CByte(Round(maxRGB - Delta))
HSBToRGB.Green = CByte(Round(h * Delta)) + HSBToRGB.Blue
Else
HSBToRGB.Green = CByte(Round(maxRGB - Delta))
HSBToRGB.Blue = CByte(HSBToRGB.Green - Round(h * Delta))
End If
End If
End If
End If
End If
End Function
A continuación, hubo alguien que ha escrito que había un error, pero no dio más detalles mucho
Pero creo que necesita para gestionar cuando h es de más de 5, por ejemplo para el color R: 130 G: 65 B: 111
If h > 5 Then
HSBToRGB.Red = CByte(Round(maxRGB))
If h > 6 Then
HSBToRGB.Blue= CByte(Round(maxRGB - Delta))
HSBToRGB.Green= CByte(Round((h - 6) * Delta)) HSBToRGB.Blue
Else
HSBToRGB.Green= CByte(Round(maxRGB - Delta))
HSBToRGB.Blue = CByte(HSBToRGB.Green- Round((h - 6) * Delta))
End If
¿Es necesario agregar en ese trozo de código? Y supongo que debe entrar en HSB a RGB (en mi C # conversión)
...
if (s != 0) {
delta = s * maxRGB / 255;
if (h > 5)
rgb.Red = Convert.ToByte(Math.Round(maxRGB));
if (h > 6)
{
rgb.Green = Convert.ToByte(Math.Round(maxRGB - delta));
rgb.Blue = Convert.ToByte(rgb.Green - Math.Round((h - 6) * delta));
}
if (h > 3)
{
...
también, en caso de ser como anteriormente, o
if (h > 6) { }
else if (h > 3) { }
Solución
El uso de los métodos incorporados en objeto Color de .NET es un no-motor de arranque, ya que, como varias de las respuestas señalan, que no son compatibles con el revés (la conversión de un color HSB a RGB). Además, Color.GetBrightness realidad vuelve ligereza , en lugar de brillo / valor. Hay mucha confusión sobre las diferencias entre el HSB / HSV y espacios de color HSL debido a sus similitudes ( Wikipedia ). Veo un montón de selectores de color que terminan usando el algoritmo y / o modelo equivocado.
Las miradas código original a mí como se echa de menos algunos escenarios posibles cuando se calcula el valor para el matiz, dado un color RGB. Es un poco difícil para mí seguir las adiciones que se está contemplando al código, pero lo primero que salta a mí (y que no parecen sugerir la corrección) es que cuando la saturación = 0, se establece hue a -1. Cuando más tarde se multiplican por 60 el matiz, se termina con -60, a continuación, se agrega que al 360 (If h < 0 Then h = h + 360), produciendo un resultado de 300, lo cual no es correcto.
I usar el siguiente código (en VB.NET) para convertir entre RGB y HSB (que llamo HSV). Los resultados se han probado muy ampliamente, y los resultados son prácticamente idénticas a las previstas por el selector de colores de Photoshop (aparte de la compensación se hace por perfiles de color). La principal diferencia entre el código señalizadas y la mía (aparte de la parte importante que calcula el matiz) es que prefiero la normalización de los valores RGB a estar entre 0 y 1 para hacer los cálculos, en lugar de trabajar con los valores originales entre 0 y 255 . Esto elimina algunas de las ineficiencias y las múltiples conversiones en el código original que haya publicado, también.
Public Function RGBtoHSV(ByVal R As Integer, ByVal G As Integer, ByVal B As Integer) As HSV
''# Normalize the RGB values by scaling them to be between 0 and 1
Dim red As Decimal = R / 255D
Dim green As Decimal = G / 255D
Dim blue As Decimal = B / 255D
Dim minValue As Decimal = Math.Min(red, Math.Min(green, blue))
Dim maxValue As Decimal = Math.Max(red, Math.Max(green, blue))
Dim delta As Decimal = maxValue - minValue
Dim h As Decimal
Dim s As Decimal
Dim v As Decimal = maxValue
''# Calculate the hue (in degrees of a circle, between 0 and 360)
Select Case maxValue
Case red
If green >= blue Then
If delta = 0 Then
h = 0
Else
h = 60 * (green - blue) / delta
End If
ElseIf green < blue Then
h = 60 * (green - blue) / delta + 360
End If
Case green
h = 60 * (blue - red) / delta + 120
Case blue
h = 60 * (red - green) / delta + 240
End Select
''# Calculate the saturation (between 0 and 1)
If maxValue = 0 Then
s = 0
Else
s = 1D - (minValue / maxValue)
End If
''# Scale the saturation and value to a percentage between 0 and 100
s *= 100
v *= 100
''# Return a color in the new color space
Return New HSV(CInt(Math.Round(h, MidpointRounding.AwayFromZero)), _
CInt(Math.Round(s, MidpointRounding.AwayFromZero)), _
CInt(Math.Round(v, MidpointRounding.AwayFromZero)))
End Function
no publicar el código que se utiliza para convertir de una HSB (que yo llamo HSV) de color a RGB, pero aquí es lo que yo uso, una vez más se trabaja con valores intermedios que se encuentran entre 0 y 1:
Public Function HSVtoRGB(ByVal H As Integer, ByVal S As Integer, ByVal V As Integer) As RGB
''# Scale the Saturation and Value components to be between 0 and 1
Dim hue As Decimal = H
Dim sat As Decimal = S / 100D
Dim val As Decimal = V / 100D
Dim r As Decimal
Dim g As Decimal
Dim b As Decimal
If sat = 0 Then
''# If the saturation is 0, then all colors are the same.
''# (This is some flavor of gray.)
r = val
g = val
b = val
Else
''# Calculate the appropriate sector of a 6-part color wheel
Dim sectorPos As Decimal = hue / 60D
Dim sectorNumber As Integer = CInt(Math.Floor(sectorPos))
''# Get the fractional part of the sector
''# (that is, how many degrees into the sector you are)
Dim fractionalSector As Decimal = sectorPos - sectorNumber
''# Calculate values for the three axes of the color
Dim p As Decimal = val * (1 - sat)
Dim q As Decimal = val * (1 - (sat * fractionalSector))
Dim t As Decimal = val * (1 - (sat * (1 - fractionalSector)))
''# Assign the fractional colors to red, green, and blue
''# components based on the sector the angle is in
Select Case sectorNumber
Case 0, 6
r = val
g = t
b = p
Case 1
r = q
g = val
b = p
Case 2
r = p
g = val
b = t
Case 3
r = p
g = q
b = val
Case 4
r = t
g = p
b = val
Case 5
r = val
g = p
b = q
End Select
End If
''# Scale the red, green, and blue values to be between 0 and 255
r *= 255
g *= 255
b *= 255
''# Return a color in the new color space
Return New RGB(CInt(Math.Round(r, MidpointRounding.AwayFromZero)), _
CInt(Math.Round(g, MidpointRounding.AwayFromZero)), _
CInt(Math.Round(b, MidpointRounding.AwayFromZero)))
End Function
EDIT: Este código es muy similar a la proporcionada en C por Richard J. Ross III. Me acosa como a muchos algoritmos diferentes que pude encontrar en línea, volvió a escribir mucho código tomar prestado lo mejor de cada uno de ellos, y lo hice pruebas exhaustivas para verificar la exactitud de los resultados. Me he olvidado de señalar que tomé prestado de código, ya que esto era sólo para una biblioteca privada. Tal vez la versión VB ayude a alguien que no quiere hacer una conversión de C: -)
Otros consejos
Aquí está mi versión de cómo hacerlo (en C, lo siento, pero no debería ser difícil de convertir, basta con sustituir int * o double * enteros del out y ref de con, y no usan la sintaxis de puntero)
void colorlib_hsbtorgb(double hue, double saturation, double brightness, int *red, int *green, int *blue)
{
if (saturation == 0)
{
*red = *green = *blue = brightness;
}
else
{
// the color wheel consists of 6 sectors. Figure out which sector you're in.
double sectorPos = hue / 60.0;
int sectorNumber = (int)(floor(sectorPos));
// get the fractional part of the sector
double fractionalSector = sectorPos - sectorNumber;
// calculate values for the three axes of the color.
double p = brightness * (1.0 - saturation);
double q = brightness * (1.0 - (saturation * fractionalSector));
double t = brightness * (1.0 - (saturation * (1 - fractionalSector)));
// assign the fractional colors to r, g, and b based on the sector the angle is in.
switch (sectorNumber)
{
case 0:
*red = brightness;
*green = t;
*blue = p;
break;
case 1:
*red = q;
*green = brightness;
*blue = p;
break;
case 2:
*red = p;
*green = brightness;
*blue = t;
break;
case 3:
*red = p;
*green = q;
*blue = brightness;
break;
case 4:
*red = t;
*green = p;
*blue = brightness;
break;
case 5:
*red = brightness;
*green = p;
*blue = q;
break;
}
}
}
RGB a HSB:
void colorlib_rgbtohsb(int red, int green, int blue, double *hue, double *saturation, double *brightness)
{
double dRed = red / 255;
double dGreen = green / 255;
double dBlue = blue / 255;
double max = fmax(dRed, fmax(dGreen, dBlue));
double min = fmin(dRed, fmin(dGreen, dBlue));
double h = 0;
if (max == dRed && dGreen >= dBlue)
{
h = 60 * (dGreen - dBlue) / (max - min);
}
else if (max == dRed && dGreen < dBlue)
{
h = 60 * (dGreen - dBlue) / (max - min) + 360;
}
else if (max == dGreen)
{
h = 60 * (dBlue - dRed) / (max - min) + 120;
}
else if (max == dBlue)
{
h = 60 * (dRed - dGreen) / (max - min) + 240;
}
double s = (max == 0) ? 0.0 : (1.0 - (min / max));
*hue = h;
*saturation = s;
*brightness = max;
}
Si encuentro mi código en C #, voy a editar esta respuesta ....
¿Qué pasa con el uso del color GetBrightness, métodos y GetHue GetSaturation?
Si está utilizando .NET, ¿por qué reinventar la rueda?
Dim c = Color.FromArgb(myRed, myGreen, myBlue)
Dim h = c.GetHue()
Dim s = c.GetSaturation()
Dim b = c.GetBrightness()
La conversión de RGB a HSB debería ser bastante fácil utilizando la estructura Color:
Function RGBToHSB(rgb As RGBColor) As HSBColor
Dim c As Color = Color.FromArgb(rgb.Red, rgb.Green, rgb.Blue)
RGBToHSB.Hue = c.GetHue()
RGBToHSB.Saturation = c.GetSaturation()
RGBToHSB.Brightness = c.GetBrightness()
End Function
No es compatible con el revés, sin embargo.
Solución
Se puede calcular el componente de brillo, sencillamente, ya que es el máximo de R, G y B (referencia: fórmula para RGB a HSV del Instituto de Tecnología de Rochester ). Puede escalar sin embargo que usted desea dividiendo entre 255 y multiplicando por la escala. Esto es lo mismo que hizo en su código existente:
maxRGB = Max(Max(rgb.Red, rgb.Green), rgb.Blue)
b = maxRGB
...
RGBToHSB.Brightness = b * 100 / 255
Así que, al final, se puede utilizar el built-in funciones .Net y simplemente calcular su brillo. código completo sería (con exclusión de sus tipos):
Function RGBToHSB(rgb As RGBColor) As HSBColor
Dim maxRGB As Double
maxRGB = Max(Max(rgb.Red, rgb.Green), rgb.Blue)
Dim c As Color = Color.FromArgb(rgb.Red, rgb.Green, rgb.Blue)
RGBToHSB.Hue = c.GetHue()
RGBToHSB.Saturation = c.GetSaturation() * 100
RGBToHSB.Brightness = maxRGB * 100 / 255
End Function
un poco sobre HSB (igual que el HSV)
En el sistema de HSV (también llamado HSB), el brillo de un color es su componente V. Ese componente se define simplemente como el valor máximo de cualquiera de los tres componentes RGB del color -. Los otros dos componentes RGB se ignoran cuando se determina V
Según el href="http://msdn.microsoft.com/en-us/library/system.drawing.color.getbrightness.aspx" rel="nofollow"> Documentación del Color.GetBrightness:
Obtiene el hue-saturación-brillo ( HSB ) valor de brillo para esta estructura de color.
he encontrado algunas referencias diciendo que el MSDN utiliza HSB cuando significa HSL como éste de MSDN blogs (ver los comentarios). Una prueba rápida demuestra que esto es cierto (en C #):
// Define a color which gives different HSL and HSB value
Color c = Color.FromArgb(255, 0, 0);
// Get the brightness, scale it from 0.0 - 1.0 up to 0 - 255
int bright = (int)(c.GetBrightness() * 255.00);
// Output it
Console.WriteLine(bright.ToString());
Este resulta en un valor de 127, que es claramente HSL. Si era HSB el valor debe ser el máximo de R G y B (es decir 255).
