Algorithme pour Basculer Entre RVB et TSL Valeurs de Couleur

En utilisant les méthodes intégrées .NET est la Couleur de l'objet est un non-starter parce que, comme plusieurs réponses soulignent, ils ne supportent pas l'inverse (la conversion d'un chromatique TSL, RVB). En outre, Color.GetBrightness renvoie en fait légèreté, plutôt que de luminosité/valeur. Il y a beaucoup de confusion sur les différences entre les HSB/HSV et de couleur HSL espaces en raison de leurs similitudes (Wikipédia). Je vois beaucoup de sélecteurs de couleurs qui finissent à l'aide de l'algorithme inapproprié et/ou d'un modèle.

Le code d'origine me semble qu'il manque quelques scénarios possibles lorsqu'il calcule la valeur de la teinte, donné une couleur RVB. C'est un peu difficile pour moi de suivre les ajouts que vous envisagez pour le code, mais la première chose qui saute aux yeux (et que vous n'apparaissez pas à suggérer la correction), c'est que lorsque la saturation = 0, vous réglez la teinte de -1. Lorsque, plus tard, vous multipliez la teinte de 60, vous vous retrouvez avec -60, puis vous ajoutez que, pour 360 (If h < 0 Then h = h + 360), la production d'un résultat de 300, ce qui n'est pas correct.

J'utilise le code suivant (dans VB.NET) pour convertir entre RVB et TSL (ce que j'appelle le HSV). Les résultats ont été testés très largement, et les résultats sont pratiquement identiques à ceux donnés par Photoshop sélecteur de couleur (à part de la rémunération pour les profils de couleurs). La différence majeure entre les posté code et le mien (en dehors de la partie importante qui calcule la teinte) c'est que je préfère en normalisant les valeurs RVB entre 0 et 1 pour faire les calculs, plutôt que de travailler avec l'origine des valeurs entre 0 et 255. Ceci élimine certains de l'inefficacité et de multiples conversions dans le premier code que vous avez posté, en tant que bien.

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

Vous n'avez pas de poste le code que vous utilisez pour convertir à partir d'un HSB (ce que j'appelle le HSV) de couleur RVB, mais voici ce que j'utilise, travailler de nouveau avec des valeurs intermédiaires que sont entre 0 et 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: Ce code est très similaire à celle prévue au C par Richard J. Ross III. Je traqués comme de nombreux algorithmes différents que j'ai pu trouver en ligne, a réécrit beaucoup de code empruntant le meilleur de chacun d'eux, et fait de nombreux tests pour vérifier l'exactitude des résultats. J'ai oublié de noter qui j'ai emprunté le code, que c'était juste pour une bibliothèque privée. Peut-être que la version de visual basic va aider quelqu'un qui ne veut pas faire une conversion de C. 🙂

Que penser de l'utilisation de la Couleur GetBrightness, GetHue et GetSaturation méthodes?

La conversion de RVB à HSB devrait être plutôt facile à l'aide de la Color structure:

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

Il ne supporte pas l'inverse, si.