Color

• Representación JSON

Representa un color en el espacio de color RGBA. Esta representación se ha diseñado para que sea fácil convertirla a representaciones de color en varios idiomas y viceversa, en lugar de para que sea compacta. Por ejemplo, los campos de esta representación se pueden proporcionar de forma trivial al constructor de "java.awt.Color" en Java. También se pueden proporcionar de forma trivial al método "+colorWithRed:green:blue:alpha" de UIColor en iOS. Además, con un poco de trabajo, se puede dar formato fácilmente a una cadena "rgba()" de CSS en JavaScript.

Nota: Este proto no incluye información sobre el espacio de color absoluto que se debe usar para interpretar el valor RGB (por ejemplo, sRGB, Adobe RGB, DCI-P3, BT.2020, etc.). De forma predeterminada, las aplicaciones DEBEN asumir el espacio de color sRGB.

Ejemplo (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();
 }
 // ...

Ejemplo (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;
}
// ...

Ejemplo (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('');
};

// ...

Representación JSON
{ "red": number, "green": number, "blue": number, "alpha": number }

Campos
red	number Cantidad de rojo del color como valor en el intervalo [0, 1].
green	number Cantidad de verde del color como valor en el intervalo [0, 1].
blue	number Cantidad de azul del color como valor del intervalo [0, 1].
alpha	number La fracción de este color que se debe aplicar al píxel. Es decir, el color final del píxel se define mediante la siguiente ecuación: color del píxel = alfa * (este color) + (1,0 - alfa) * (color de fondo) Esto significa que el valor 1,0 corresponde a un color sólido, mientras que el valor 0,0 corresponde a un color completamente transparente. Se usa un mensaje de envoltorio en lugar de un escalar flotante simple para que se pueda distinguir entre un valor predeterminado y el valor que no se ha definido. Si se omite, este objeto de color se renderizará como un color sólido (como si el valor alfa se hubiera proporcionado explícitamente con un valor de 1.0).