Conversion de HSV (HSB en Java) en RGB sans utiliser java.awt.Color (non autorisé sur Google App Engine)

J'ai pensé que je devrais poster cette question, même si j'ai déjà trouvé une solution, comme une implémentation de Java n'était pas disponible quand j'ai cherché pour elle.

À l'aide de HSV au lieu de RVB permet la génération de couleurs avec la même saturation et de la luminosité (quelque chose que je voulais).

Google App Engine n'autorise pas l'utilisation de java.awt.De la couleur, afin de faire ce qui suit pour convertir entre HSV et RGB n'est pas une option:

Color c = Color.getHSBColor(hue, saturation, value);
String rgb = Integer.toHexString(c.getRGB());

Edit: j'ai déplacé ma réponse comme décrit dans le commentaire de Nick Johnson.

Ex animo, - Alexander.

source d'informationauteur yngling

Je ne sais rien au sujet de la couleur de mathématiques, mais je peux offrir cette alternative structure du code, qui chatouille mon sens de l'esthétique, car il fait évident pour moi la façon dont chacun des 6 cas est juste un autre permutation de valeur, t et p. (J'ai aussi une peur irrationnelle de long si les autres chaînes).

public static String hsvToRgb(float hue, float saturation, float value) {
int h = (int)(hue * 6);
float f = hue * 6 - h;
float p = value * (1 - saturation);
float q = value * (1 - f * saturation);
float t = value * (1 - (1 - f) * saturation);
switch (h) {
case 0: return rgbToString(value, t, p);
case 1: return rgbToString(q, value, p);
case 2: return rgbToString(p, value, t);
case 3: return rgbToString(p, q, value);
case 4: return rgbToString(t, p, value);
case 5: return rgbToString(value, p, q);
default: throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + hue + ", " + saturation + ", " + value);
}
}
public static String rgbToString(float r, float g, float b) {
String rs = Integer.toHexString((int)(r * 256));
String gs = Integer.toHexString((int)(g * 256));
String bs = Integer.toHexString((int)(b * 256));
return rs + gs + bs;
}

5

Vous devez utiliser le HSBtoRGB de mise en œuvre fournis par Oracle, la copie de son code source dans votre projet. java.awt.La couleur est open-source. Les algorithmes fournis par Peter Recore et Yngling ne sont pas robustes et sera de retour RVB illégale des valeurs comme "256,256,0" pour certaines entrées. Oracle mise en oeuvre est robuste, l'utiliser à la place.

Mon code pour la conversion:

     /**
* @param H
*            0-360
* @param S
*            0-100
* @param V
*            0-100
* @return color in hex string
*/
public static String hsvToRgb(float H, float S, float V) {
float R, G, B;
H /= 360f;
S /= 100f;
V /= 100f;
if (S == 0)
{
R = V * 255;
G = V * 255;
B = V * 255;
} else {
float var_h = H * 6;
if (var_h == 6)
var_h = 0; //H must be < 1
int var_i = (int) Math.floor((double) var_h); //Or ... var_i =
//floor( var_h )
float var_1 = V * (1 - S);
float var_2 = V * (1 - S * (var_h - var_i));
float var_3 = V * (1 - S * (1 - (var_h - var_i)));
float var_r;
float var_g;
float var_b;
if (var_i == 0) {
var_r = V;
var_g = var_3;
var_b = var_1;
} else if (var_i == 1) {
var_r = var_2;
var_g = V;
var_b = var_1;
} else if (var_i == 2) {
var_r = var_1;
var_g = V;
var_b = var_3;
} else if (var_i == 3) {
var_r = var_1;
var_g = var_2;
var_b = V;
} else if (var_i == 4) {
var_r = var_3;
var_g = var_1;
var_b = V;
} else {
var_r = V;
var_g = var_1;
var_b = var_2;
}
R = var_r * 255; //RGB results from 0 to 255
G = var_g * 255;
B = var_b * 255;
}
String rs = Integer.toHexString((int) (R));
String gs = Integer.toHexString((int) (G));
String bs = Integer.toHexString((int) (B));
if (rs.length() == 1)
rs = "0" + rs;
if (gs.length() == 1)
gs = "0" + gs;
if (bs.length() == 1)
bs = "0" + bs;
return "#" + rs + gs + bs;
}

Exemple d'utilisation sur Android:

tv.setBackgroundColor(Color.parseColor((ColorOperations.hsvToRgb(100, 100, 57))));

La solution a été trouvée ici: http://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/

Martin Ankerl fournit un bon post sur le sujet, et fournit un script Ruby. Pour ceux qui sont trop occupés (ou paresseux) pour la mettre en œuvre en Java, voici celui que j'ai fait (je suis sûr qu'il peut être écrit de manière plus efficace, n'hésitez pas à commenter):

public static String hsvToRgb(float hue, float saturation, float value) {
float r, g, b;
int h = (int)(hue * 6);
float f = hue * 6 - h;
float p = value * (1 - saturation);
float q = value * (1 - f * saturation);
float t = value * (1 - (1 - f) * saturation);
if (h == 0) {
r = value;
g = t;
b = p;
} else if (h == 1) {
r = q;
g = value;
b = p;
} else if (h == 2) {
r = p;
g = value;
b = t;
} else if (h == 3) {
r = p;
g = q;
b = value;
} else if (h == 4) {
r = t;
g = p;
b = value;
} else if (h <= 6) {
r = value;
g = p;
b = q;
} else {
throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + hue + ", " + saturation + ", " + value);
}
String rs = Integer.toHexString((int)(r * 255));
String gs = Integer.toHexString((int)(g * 255));
String bs = Integer.toHexString((int)(b * 255));
return rs + gs + bs;
}

Utilisation ColorUtils qui fournit

HSLToColor(float\[\] hsl)

[RGBToHSL(int r, int g, int b, float\[\] hsl)]

Méthodes qui sont très faciles à convertir les uns les autres!

Par exemple:

float[] hsl = new float[]{1.5, 2.0, 1.5};
int color = ColorUtils.HSLToColor(hsl);

Maintenant obtenir la couleur

float[] hslStub = new float[3];
float[] hslFromColor = ColorUtils.colorToHSL(color, hslStub);

Maintenant obtenir la lgv

Ici est la code source.

La réponse par @Pierre Recore ne pas utiliser de l'arrondissement.

Probablement un peu plus de bonne façon de l'utiliser est de copier le contenu de java.awt.La couleur et c'est la façon dont il a regardé dans la version 6 de Java:

 public static int HSBtoRGB(float hue, float saturation, float brightness) {
int r = 0, g = 0, b = 0;
if (saturation == 0) {
r = g = b = (int) (brightness * 255.0f + 0.5f);
} else {
float h = (hue - (float)Math.floor(hue)) * 6.0f;
float f = h - (float)java.lang.Math.floor(h);
float p = brightness * (1.0f - saturation);
float q = brightness * (1.0f - saturation * f);
float t = brightness * (1.0f - (saturation * (1.0f - f)));
switch ((int) h) {
case 0:
r = (int) (brightness * 255.0f + 0.5f);
g = (int) (t * 255.0f + 0.5f);
b = (int) (p * 255.0f + 0.5f);
break;
case 1:
r = (int) (q * 255.0f + 0.5f);
g = (int) (brightness * 255.0f + 0.5f);
b = (int) (p * 255.0f + 0.5f);
break;
case 2:
r = (int) (p * 255.0f + 0.5f);
g = (int) (brightness * 255.0f + 0.5f);
b = (int) (t * 255.0f + 0.5f);
break;
case 3:
r = (int) (p * 255.0f + 0.5f);
g = (int) (q * 255.0f + 0.5f);
b = (int) (brightness * 255.0f + 0.5f);
break;
case 4:
r = (int) (t * 255.0f + 0.5f);
g = (int) (p * 255.0f + 0.5f);
b = (int) (brightness * 255.0f + 0.5f);
break;
case 5:
r = (int) (brightness * 255.0f + 0.5f);
g = (int) (p * 255.0f + 0.5f);
b = (int) (q * 255.0f + 0.5f);
break;
}
}
return 0xff000000 | (r << 16) | (g << 8) | (b << 0);
}

Arrondi ici semble être correct.

Utilisant SWT vous pouvez utiliser l'extrait de code suivant:

RGB rgb = new RGB(r, g, b);
float[] hsbColor = rgb.getHSB();
rgb = new RGB(hsbColor[0], hsbColor[1], hsbColor[2]);

Vous devez vous connecter pour publier un commentaire.