Cómo obtener mediante programación una lista de colores de un degradado en Android

Question

en Android Me gustaría dibujar un PieChart con un número dinámico de pies. Cada pastel debe tener un color diferente al de un degradado.

Por ejemplo, me gustaría tener un degradado de marrón claro a marrón oscuro. Si necesito dibujar cinco pasteles, necesito cinco volors desde el principio hasta el final de este gradiente.

¿Cómo puedo hacer eso en Java con el marco de Android?

descubrí que puedo crear un LinearGradient para una línea, es decir:

LinearGradient lg = new LinearGradient(1, 1, 5, 5, toRGB("lightbrown"), toRGB("darkbrown"), TileMode.REPEAT); 

pero no encontró ninguna función para obtener un color de esta línea, es decir:

// for the five needed RGB colors from the gradient line 
lg.getRGBColor(1, 1); 
lg.getRGBColor(2, 2); 
lg.getRGBColor(3, 3); 
lg.getRGBColor(4, 4); 
lg.getRGBColor(5, 5); 

¿Tienes alguna idea de cómo puedo conseguir esto?

Gracias!

Answer 1

No puede obtener estos valores directamente del LinearGradient. El degradado no contiene el dibujo real. Para obtener estos valores, puede pintarlos en un lienzo y sacar los colores del lienzo, o lo que yo sugeriría sería calcular los valores usted mismo.

Es un gradiente lineal repetitivo en cinco pasos y tiene los valores RGB para el primer y el último color. El resto es solo matemática. Aquí está el código de pseudo:

int r1 = startColor.red; 
int g1 = startColor.green; 
int b1 = startColor.blue; 

int r2 = endColor.red; 
int g2 = endColor.green; 
int b2 = endColor.blue; 

int redStep = r2 - r1/4; 
int greenStep = g2 - g1/4; 
int blueStep = b2 - b1/4; 

firstColor = new Color(r1, g1, b1); 
secondColor = new Color(r1 + redStep, g1 + greenStep, b1 + blueStep); 
thirdColor = new Color(r1 + redStep * 2, g1 + greenStep * 2, b1 + blueStep * 2); 
fourthColor = new Color(r1 + redStep * 3, g1 + greenStep * 3, b1 + blueStep * 3); 
fifthColor = new Color(r1 + redStep * 4, g1 + greenStep * 4, b1 + blueStep * 4); 

Answer 2

Otro enfoque que es un poco más reutilizable (me parece que tropiezan con este problema todo el tiempo). Es un poco más código. Aquí está el uso:

int[] colors = {toRGB("lightbrown"), toRGB("darkbrown")};//assuming toRGB : String -> Int 
    float[] positions = {1, 5}; 
    getColorFromGradient(colors, positions, 1) 
    //... 
    getColorFromGradient(colors, positions, 5) 

Funciones de apoyo

public static int getColorFromGradient(int[] colors, float[] positions, float v){ 

    if(colors.length == 0 || colors.length != positions.length){ 
     throw new IllegalArgumentException(); 
    } 

    if(colors.length == 1){ 
     return colors[0]; 
    } 

    if(v <= positions[0]) { 
     return colors[0]; 
    } 

    if(v >= positions[positions.length-1]) { 
     return colors[positions.length-1]; 
    } 

    for(int i = 1; i < positions.length; ++i){ 
     if(v <= positions[i]){ 
      float t = (v - positions[i-1])/(positions[i] - positions[i-1]); 
      return lerpColor(colors[i-1], colors[i], t); 
     } 
    } 

    //should never make it here 
    throw new RuntimeException(); 
} 

public static int lerpColor(int colorA, int colorB, float t){ 
    int alpha = (int)Math.floor(Color.alpha(colorA) * (1 - t) + Color.alpha(colorB) * t); 
    int red = (int)Math.floor(Color.red(colorA) * (1 - t) + Color.red(colorB) * t); 
    int green = (int)Math.floor(Color.green(colorA) * (1 - t) + Color.green(colorB) * t); 
    int blue = (int)Math.floor(Color.blue(colorA) * (1 - t) + Color.blue(colorB) * t); 

    return Color.argb(alpha, red, green, blue); 
}