Androide Farbe zwischen zwei Farben, basierend auf Prozent?

Ich würde gerne berechnen, die je nach Farbe einen prozentualen Wert:

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);
}

Wie kann ich berechnen, dass die Letzte, was? Wäre es OK, wenn gelb angezeigt wird, bei 50%.

Habe ich versucht, dieses:

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));
}

Gut das funktioniert, aber ich würde gerne die Farben um die 50% mehr lightend wie verwende ich Sie auf einem grauen hintergrund.. wie kann ich erreichen, dass?

Dank!

UPDATE
Ich habe versucht, zu konvertieren, YUV, wie es wurde vorgeschlagen, in den Kommentaren. Aber ich habe immer noch das gleiche problem, dass bei 50% ist es zu dunkel.
Weitere in diese Lösung habe ich bei <5% jetzt weiß als Farbe. Wenn ich nicht berechnen kann float y = ave(...);, aber nehmen Sie nur float y = c0.y es ist ein wenig besser, aber at <20% habe ich dann cyan Farbe ... ich bin nicht so viel in Farbe-Formate :-/
Vielleicht mache ich etwas falsch bei der Berechnung? Die Konstanten sind entnommen aus 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));
    }
}

InformationsquelleAutor der Frage Stuck | 2010-12-11

54

Können Sie versuchen, mit ArgbEvaluator Klasse aus der android-API: http://developer.android.com/reference/android/animation/ArgbEvaluator.html :
```
new ArgbEvaluator().evaluate(0.75, 0x00ff00, 0xff0000);
```
Beachten Sie, dass es ein bug ist ( http://code.google.com/p/android/issues/detail?id=36158 ) im alpha-Kanal Berechnung, so sollten Sie Werte verwenden, die ohne alpha-Wert.

InformationsquelleAutor der Antwort Equidamoid

Meine $0,02, ich fand diese Antwort und codiert die richtige Lösung. (Dank an Alnitak für den HSV-Tipp!)

Für Copy+Paste:

  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);
  }

InformationsquelleAutor der Antwort Mark Renouf

8

Interpolation, wie dies geschieht am besten in HSL-oder HSV Farbräume (und nicht YUV).

Der Grund, warum die mid-range-Farben wirken "matschig" ist, weil wenn man einfach Linear ramp-up der red (#ff0000) in der gleichen Zeit wie ramping-down-grün (#00ff00) die mittlere Farbe landet als #808000 statt #ffff00.

Stattdessen, finden Sie die HSL (oder HSV) entspricht von Ihrer Farbe ab, und das gleiche für die end-Farbe. Interpolieren in dass Farbraum, und dann für jeden Punkt zurück konvertieren nach RGB wieder.

Da die S und L (oder V) Werte gelten für voll gesättigte rot und grün, nur die H (Farbton) für eine variable zu ändern, geben Sie die richtige Wirkung eines Spektrum der Farbe.

InformationsquelleAutor der Antwort Alnitak

Einige Lösungen dieser thread hat bei mir nicht funktioniert, so erstelle ich eine andere Lösung. Vielleicht ist es ja nützlich für jemanden.

/**
 * 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;
}

InformationsquelleAutor der Antwort J.S.R - Silicornio

Ok, nach 2 Stunden Konvertierung auf yuv, hsv, etc pp... ich gebe auf. Nun mache ich es einfach so:

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));
    }
}

Durch ausdrücklich mit gelb als die mittlere Farbe, die erzeugten Farben sind heller 🙂

Eh.. wenn jemand eine gute andere Lösung gibt, würde ich mich freuen.

InformationsquelleAutor der Antwort Stuck

Ich wollte nur ein update Daneben Renouf ' s Antwort zu behandeln, alpha-Kanal:

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);
}

InformationsquelleAutor der Antwort tir38

Hier sind 2 Möglichkeiten, um zu interpolieren:

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);
}

InformationsquelleAutor der Antwort android developer

-2

Hier ist eine pseudocode-Funktion, die Linear interpoliert zwischen 2 Farben (staying in RGB space). Ich bin über eine Klasse namens Farbe hier statt ints für Klarheit.

bAmount ist zwischen 0 und 1 (für die interpolation)

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;
}

InformationsquelleAutor der Antwort Christopher O.

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.