$ git log --diff-filter=D --summary | grep "delete" | sort
Хорошо, после 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));
}
}
Благодаря простоте, используя желтый в качестве среднего цвета, сгенерированные цвета становятся ярче: -)
В любом случае ... если у кого-то есть хорошее другое решение Я был бы признателен.
Подобную интерполяцию лучше всего выполнять в HSL или HSV цветовых пространствах (а не YUV).
Причина, по которой цвета среднего диапазона выглядят «мутными», заключается в том, что если вы просто линейно увеличиваете красный (#ff0000
) одновременно с уменьшением зеленого (#00ff00
), средний цвет получается как #808000
вместо #ffff00
.
Вместо этого найдите HSL (или HSV) эквивалент вашего начального цвета, и то же самое для конечного цвета. Интерполируйте в это цветовое пространство, а затем для каждой точки снова конвертируйте обратно в RGB.
Поскольку значения S
и L
(или V
) одинаковы для полностью насыщенного красного и зеленого, изменится только переменная H
(оттенок), что даст надлежащий эффект спектр цвета.
Некоторые из решений этой темы не работали для меня, поэтому я создаю другое решение. Может быть, это кому-нибудь пригодится.
/**
* 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;
}
Вы можете попробовать использовать класс 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 ) в расчете альфа-канала, поэтому вы должны использовать значения без альфа-значения.
Мои $ 0,02, я нашел этот ответ и закодировал правильное решение. (Спасибо Alnitak за отзыв о HSV!)
Для копирования + вставки:
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);
}
Вот 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);
}
В качестве обновленного решения вы можете использовать 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)
Я просто хотел обновить ответ Марка Ренуфа для обработки и альфа-канала:
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);
}
Вот функция псевдокода, которая интерполирует линейно между 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;
}