цвет андроида между двумя цветами, в процентах? - PullRequest
29 голосов
/ 11 декабря 2010

Я хотел бы рассчитать цвет в зависимости от процентного значения:

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

Как я могу рассчитать эту последнюю вещь? Было бы хорошо, если бы желтый появился на 50%.

Я пробовал это:

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

Ну, это работает, но мне бы хотелось, чтобы цвета на 50% были более светлыми, когда я использую их на сером фоне ... как я могу это сделать?

Спасибо!

UPDATE Я пытался преобразовать в YUV, как это было предложено в комментариях. Но у меня все еще та же проблема, что на 50% это темно. Дополнительный в этом решении у меня на <5% сейчас белый как цвет. Если я не вычисляю <code>float y = ave(...);, а просто беру float y = c0.y, это немного лучше, но при <20% у меня есть тогда голубой цвет ... Я не так уж много в цветовых форматах: - / Может я что-то не так делаю в расчете? Константы взяты из Википедии </p>

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

Ответы [ 9 ]

62 голосов
/ 23 апреля 2013

Вы можете попробовать использовать класс ArgbEvaluator из Android API: http://developer.android.com/reference/android/animation/ArgbEvaluator.html:

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

Обратите внимание, что в вычислении альфа-канала есть ошибка (http://code.google.com/p/android/issues/detail?id=36158), поэтому вам следуетиспользуйте значения без альфа-значения.

27 голосов
/ 24 октября 2011

Мои 0,02 доллара, я нашел этот ответ и кодировал правильное решение (Спасибо Alnitak за отзыв о ВПГ!)

Для копирования + вставки:

  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);
  }
8 голосов
/ 11 декабря 2010

Такая интерполяция лучше всего выполняется в HSL или HSV цветовых пространствах (а не YUV).

Причина, по которой цвета среднего диапазона выглядят «мутными», заключается в том, что если вы просто линейно увеличиваете красный (#ff0000) одновременно с уменьшением зеленого (#00ff00), средний цвет заканчивается как #808000 вместо #ffff00.

Вместо этого найдите HSL (или HSV), эквивалентный вашему начальному цвету, и такой же для конечного цвета. Интерполируйте в это цветовое пространство, а затем для каждой точки снова конвертируйте обратно в RGB.

Поскольку значения S и L (или V) одинаковы для полностью насыщенного красного и зеленого, изменится только переменная H (оттенок), что придаст должный эффект спектр цвета.

5 голосов
/ 02 марта 2017

Некоторые из решений этой темы не работают для меня, поэтому я создаю другое решение.Может быть, это кому-нибудь пригодится.

/**
 * 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;
}
4 голосов
/ 11 декабря 2010

Хорошо, после 2 часов преобразования в yuv, hsv и т. Д. Pp ... Я сдаюсь.Теперь я делаю это так:

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

Благодаря простоте, использующей желтый в качестве среднего цвета, сгенерированные цвета становятся ярче: -)

В любом случае ... если у кого-то есть хорошее другое решениеЯ был бы признателен.

3 голосов
/ 23 июля 2016

Я просто хотел обновить Марк Ренуф ответил , чтобы также обрабатывать альфа-канал:

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);
}
0 голосов
/ 25 июня 2019

В качестве обновленного решения вы можете использовать ColorUtils#blendARGB из поддержки Android или AndroidX API:

val startColor = ContextCompat.getColor(context, R.color.white)
val endColor = ContextCompat.getColor(context, R.color.yellow)
ColorUtils.blendARGB(startColor, endColor, 0.75)
0 голосов
/ 07 апреля 2016

Вот 2 способа интерполировать:

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);
}
0 голосов
/ 11 декабря 2010

Вот функция псевдокода, которая линейно интерполирует между 2 цветами (staying in RGB space).Я использую класс Color для ясности здесь.

bAmount находится между 0 и 1 (для интерполяции)

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;
}
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...