Color androide entre dos colores, basado en el porcentaje?

Me gustaría calcular el color en función de un valor porcentual:

float percentage = x/total; int color; if (percentage >= 0.95) { color = Color.GREEN; } else if (percentage <= 0.5) { color = Color.RED; } else { // color = getColor(Color.Green, Color.RED, percentage); } 

¿Cómo puedo calcular esa última cosa? Estaría bien si el amarillo aparece al 50%.

He intentado esto:

 private int getColor(int c0, int c1, float p) { int a = ave(Color.alpha(c0), Color.alpha(c1), p); int r = ave(Color.red(c0), Color.red(c1), p); int g = ave(Color.green(c0), Color.green(c1), p); int b = ave(Color.blue(c0), Color.blue(c1), p); return Color.argb(a, r, g, b); } private int ave(int src, int dst, float p) { return src + java.lang.Math.round(p * (dst - src)); } 

Bueno, esto funciona, pero me gustaría que los colores en torno al 50% son más lightend como los uso en un fondo gris .. ¿cómo puedo lograr eso?

¡Gracias!

UPDATE He intentado convertir a YUV como se sugirió en los comentarios. Pero todavía tengo el mismo problema que en el 50% es a oscuras. Adicional en esta solución tengo a <5% ahora blanco como color. Si no calculo float y = ave(...); , Pero acaba de tomar float y = c0.y es un poco mejor, pero a <20% tengo entonces color cian … No estoy tanto en los formatos de color: – / Tal vez estoy haciendo algo mal en el ¿cálculo? Las constantes se toman de Wikipedia

 public class ColorUtils { private static class Yuv { public float y; public float u; public float v; public Yuv(int c) { int r = Color.red(c); int g = Color.green(c); int b = Color.blue(c); this.y = 0.299f * r + 0.587f * g + 0.114f * b; this.u = (b - y) * 0.493f; this.v = (r - y) * 0.877f; } } public static int getColor(int color0, int color1, float p) { Yuv c0 = new Yuv(color0); Yuv c1 = new Yuv(color1); float y = ave(c0.y, c1.y, p); float u = ave(c0.u, c1.u, p); float v = ave(c0.v, c1.v, p); int b = (int) (y + u / 0.493f); int r = (int) (y + v / 0.877f); int g = (int) (1.7f * y - 0.509f * r - 0.194f * b); return Color.rgb(r, g, b); } private static float ave(float src, float dst, float p) { return src + Math.round(p * (dst - src)); } } 

8 Solutions collect form web for “Color androide entre dos colores, basado en el porcentaje?”

Puede probar con la clase ArgbEvaluator desde la API de Android: http://developer.android.com/reference/android/animation/ArgbEvaluator.html :

 new ArgbEvaluator().evaluate(0.75, 0x00ff00, 0xff0000); 

Tenga en cuenta que hay un error ( http://code.google.com/p/android/issues/detail?id=36158 ) en el cálculo del canal alfa, por lo que debe utilizar valores sin valor alfa.

Mis $ 0.02, encontré esta respuesta y codifiqué la solución correcta. (Gracias a Alnitak por la punta HSV!)

Para Copiar + Pegar:

  private float interpolate(float a, float b, float proportion) { return (a + ((b - a) * proportion)); } /** Returns an interpoloated color, between <code>a</code> and <code>b</code> */ private int interpolateColor(int a, int b, float proportion) { float[] hsva = new float[3]; float[] hsvb = new float[3]; Color.colorToHSV(a, hsva); Color.colorToHSV(b, hsvb); for (int i = 0; i < 3; i++) { hsvb[i] = interpolate(hsva[i], hsvb[i], proportion); } return Color.HSVToColor(hsvb); } 

La interpolación como esta se hace mejor en espacios de color HSL o HSV (y no en YUV).

La razón por la que los colores de gama media parecen "fangosos" es porque si simplemente se incrementa linealmente el rojo ( #ff0000 ) al mismo tiempo que se desciende verde ( #00ff00 ) el color medio termina como #808000 lugar de #ffff00 .

En su lugar, encuentre el HSL (o HSV) equivalente de su color inicial, y lo mismo para el color final. Interpolar en ese espacio de color y luego, para cada punto, vuelva a convertirlo de nuevo en RGB.

Puesto que los valores S y L (o V ) son los mismos para el rojo y el verde totalmente saturados, sólo cambiará la variable H (tono), dando el efecto apropiado de un espectro de color.

Ok, después de 2 horas de conversión a yuv, hsv, etc pp … Me doy por vencido. Ahora lo hago así:

 public class ColorUtils { private static int FIRST_COLOR = Color.GREEN; private static int SECOND_COLOR = Color.YELLOW; private static int THIRD_COLOR = Color.RED; public static int getColor(float p) { int c0; int c1; if (p <= 0.5f) { p *= 2; c0 = FIRST_COLOR; c1 = SECOND_COLOR; } else { p = (p - 0.5f) * 2; c0 = SECOND_COLOR; c1 = THIRD_COLOR; } int a = ave(Color.alpha(c0), Color.alpha(c1), p); int r = ave(Color.red(c0), Color.red(c1), p); int g = ave(Color.green(c0), Color.green(c1), p); int b = ave(Color.blue(c0), Color.blue(c1), p); return Color.argb(a, r, g, b); } private static int ave(int src, int dst, float p) { return src + java.lang.Math.round(p * (dst - src)); } } 

Por la explicación usando amarillo como el color medio, los colores generados son más brillantes 🙂

De todos modos … si alguien tiene una buena otra solución, lo agradecería.

Algunas de las soluciones de este hilo no funcionaron para mí, así que creo otra solución. Tal vez sea útil para alguien.

 /** * Get the color between two given colors * @param colorStart int color start of degradate * @param colorEnd int color end of degradate * @param percent int percent to apply (0 to 100) * @return int color of degradate for given percent */ public static int getColorOfDegradate(int colorStart, int colorEnd, int percent){ return Color.rgb( getColorOfDegradateCalculation(Color.red(colorStart), Color.red(colorEnd), percent), getColorOfDegradateCalculation(Color.green(colorStart), Color.green(colorEnd), percent), getColorOfDegradateCalculation(Color.blue(colorStart), Color.blue(colorEnd), percent) ); } private static int getColorOfDegradateCalculation(int colorStart, int colorEnd, int percent){ return ((Math.min(colorStart, colorEnd)*(100-percent)) + (Math.max(colorStart, colorEnd)*percent)) / 100; } 

Sólo quería actualizar la respuesta de Mark Renouf para manejar el canal alfa también:

 private float interpolate(float a, float b, float proportion) { return (a + ((b - a) * proportion)); } /** * Returns an interpolated color, between <code>a</code> and <code>b</code> * proportion = 0, results in color a * proportion = 1, results in color b */ private int interpolateColor(int a, int b, float proportion) { if (proportion > 1 || proportion < 0) { throw new IllegalArgumentException("proportion must be [0 - 1]"); } float[] hsva = new float[3]; float[] hsvb = new float[3]; float[] hsv_output = new float[3]; Color.colorToHSV(a, hsva); Color.colorToHSV(b, hsvb); for (int i = 0; i < 3; i++) { hsv_output[i] = interpolate(hsva[i], hsvb[i], proportion); } int alpha_a = Color.alpha(a); int alpha_b = Color.alpha(b); float alpha_output = interpolate(alpha_a, alpha_b, proportion); return Color.HSVToColor((int) alpha_output, hsv_output); } 

Aquí hay 2 maneras de interpolar:

 private static float interpolate(final float a, final float b, final float proportion) { return a + (b - a) * proportion; } /** Returns an interpoloated color, between <code>a</code> and <code>b</code> */ public static int interpolateColorHsv(final int a, final int b, final float proportion) { final float[] hsva = new float[3]; final float[] hsvb = new float[3]; Color.colorToHSV(a, hsva); Color.colorToHSV(b, hsvb); for (int i = 0; i < 3; ++i) { hsvb[i] = interpolate(hsva[i], hsvb[i], proportion); } return Color.HSVToColor(hsvb); } public static int interpolateRGB(final int colorA, final int colorB, final float bAmount) { final float aAmount = 1.0f - bAmount; final int red = (int) (Color.red(colorA) * aAmount + Color.red(colorB) * bAmount); final int green = (int) (Color.green(colorA) * aAmount + Color.green(colorB) * bAmount); final int blue = (int) (Color.blue(colorA) * aAmount + Color.blue(colorB) * bAmount); return Color.rgb(red, green, blue); } 

Aquí está una función pseudocódigo que interpola linealmente entre 2 colores (staying in RGB space ). Estoy usando una clase llamada Color aquí en lugar de Ints para mayor claridad.

BAmount está entre 0 y 1 (para interpolación)

 Color interpolate(Color colorA, Color colorB, float bAmount) { Color colorOut; float aAmount = 1.0 - bAmount; colorOut.r = colorA.r * aAmount + colorB.r * bAmount; colorOut.g = colorA.g * aAmount + colorB.g * bAmount; colorOut.b = colorA.b * aAmount + colorB.b * bAmount; return colorOut; } 
  • ¿Por qué el método onCreateOptionsMenu de Android devuelve super.onCreateOptionsMenu?
  • ¿Por qué se definen los métodos del ciclo de vida en la clase de actividad con el especificador de acceso protegido
  • Códigos de ejemplo para Android Programación Bluetooth
  • ¿Cómo subir videos a Facebook usando Facebook Android SDK 4.x?
  • Suscribir 2 diferentes Observable y onNext ambos?
  • El contexto de la aplicación devuelve null cuando se utiliza getFilesDir ()
  • Manera elegante de leer el archivo en el arsenal del byte en Java
  • Android RX - Observable.timer solo disparando una vez
  • FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.