Color

• Representação JSON

Representa uma cor no espaço de cores RGBA. Esta representação foi concebida para simplificar a conversão de/para representações de cores em vários idiomas em vez de ser compacta. Por exemplo, os campos desta representação podem ser fornecidos trivialmente ao construtor de "java.awt.Color" em Java. Também podem ser fornecidos trivialmente ao método "+colorWithRed:green:blue:alpha" de UIColor no iOS. Além disso, com um pouco de trabalho, podem ser formatados facilmente numa string "rgba()" de CSS em JavaScript.

Nota: este proto não contém informações sobre o espaço de cores absoluto que deve ser usado para interpretar o valor RGB (por exemplo, sRGB, Adobe RGB, DCI-P3, BT.2020, etc.). Por predefinição, as aplicações DEVEM assumir o espaço de cores sRGB.

Exemplo (Java):

 import com.google.type.Color;

 // ...
 public static java.awt.Color fromProto(Color protocolor) {
   float alpha = protocolor.hasAlpha()
       ? protocolor.getAlpha().getValue()
       : 1.0;

   return new java.awt.Color(
       protocolor.getRed(),
       protocolor.getGreen(),
       protocolor.getBlue(),
       alpha);
 }

 public static Color toProto(java.awt.Color color) {
   float red = (float) color.getRed();
   float green = (float) color.getGreen();
   float blue = (float) color.getBlue();
   float denominator = 255.0;
   Color.Builder resultBuilder =
       Color
           .newBuilder()
           .setRed(red / denominator)
           .setGreen(green / denominator)
           .setBlue(blue / denominator);
   int alpha = color.getAlpha();
   if (alpha != 255) {
     result.setAlpha(
         FloatValue
             .newBuilder()
             .setValue(((float) alpha) / denominator)
             .build());
   }
   return resultBuilder.build();
 }
 // ...

Exemplo (iOS / Obj-C):

 // ...
 static UIColor* fromProto(Color* protocolor) {
    float red = [protocolor red];
    float green = [protocolor green];
    float blue = [protocolor blue];
    FloatValue* alpha_wrapper = [protocolor alpha];
    float alpha = 1.0;
    if (alpha_wrapper != nil) {
      alpha = [alpha_wrapper value];
    }
    return [UIColor colorWithRed:red green:green blue:blue alpha:alpha];
 }

 static Color* toProto(UIColor* color) {
     CGFloat red, green, blue, alpha;
     if (![color getRed:&red green:&green blue:&blue alpha:&alpha]) {
       return nil;
     }
     Color* result = [[Color alloc] init];
     [result setRed:red];
     [result setGreen:green];
     [result setBlue:blue];
     if (alpha <= 0.9999) {
       [result setAlpha:floatWrapperWithValue(alpha)];
     }
     [result autorelease];
     return result;
}
// ...

Exemplo (JavaScript):

// ...

var protoToCssColor = function(rgb_color) {
   var redFrac = rgb_color.red || 0.0;
   var greenFrac = rgb_color.green || 0.0;
   var blueFrac = rgb_color.blue || 0.0;
   var red = Math.floor(redFrac * 255);
   var green = Math.floor(greenFrac * 255);
   var blue = Math.floor(blueFrac * 255);

   if (!('alpha' in rgb_color)) {
      return rgbToCssColor_(red, green, blue);
   }

   var alphaFrac = rgb_color.alpha.value || 0.0;
   var rgbParams = [red, green, blue].join(',');
   return ['rgba(', rgbParams, ',', alphaFrac, ')'].join('');
};

var rgbToCssColor_ = function(red, green, blue) {
  var rgbNumber = new Number((red << 16) | (green << 8) | blue);
  var hexString = rgbNumber.toString(16);
  var missingZeros = 6 - hexString.length;
  var resultBuilder = ['#'];
  for (var i = 0; i < missingZeros; i++) {
     resultBuilder.push('0');
  }
  resultBuilder.push(hexString);
  return resultBuilder.join('');
};

// ...

Representação JSON
{ "red": number, "green": number, "blue": number, "alpha": number }

Campos
red	number A quantidade de vermelho na cor como um valor no intervalo [0, 1].
green	number A quantidade de verde na cor como um valor no intervalo [0, 1].
blue	number A quantidade de azul na cor como um valor no intervalo [0, 1].
alpha	number A fração desta cor que deve ser aplicada ao píxel. Ou seja, a cor final do píxel é definida pela equação: cor do píxel = alfa * (esta cor) + (1,0 - alfa) * (cor de fundo) Isto significa que um valor de 1,0 corresponde a uma cor sólida, enquanto um valor de 0,0 corresponde a uma cor completamente transparente. Isto usa uma mensagem de contentor em vez de um escalar flutuante simples para que seja possível distinguir entre um valor predefinido e o valor a ser anulado. Se for omitido, este objeto de cor deve ser renderizado como uma cor sólida (como se o valor alfa tivesse sido explicitamente fornecido com um valor de 1,0).