Package google.type

Indeks

Kolor

Reprezentuje kolor w przestrzeni kolorów RGBA. Ta reprezentacja ma na celu uproszczenie procesu konwersji i zmiany kolorów w różnych językach, a nie ich kompaktowości. Na przykład pola tej reprezentacji można wprost przekazać do konstruktora java.awt.Color w Javie; można go również łatwo dostarczyć do metody +colorWithRed:green:blue:alpha UIColor w systemie iOS. Przy niewielkim nakładzie pracy można go łatwo sformatować pod postacią ciągu CSS rgba() w JavaScripcie.

Na tej stronie referencyjnej nie ma informacji o bezwzględnej przestrzeni kolorów, która powinna być wykorzystywana do interpretacji wartości RGB, np. sRGB, Adobe RGB, DCI-P3 i BT.2020. Domyślnie aplikacje powinny przyjąć przestrzeń kolorów sRGB.

Gdy należy ustalić równość kolorów, implementacje (o ile nie udokumentowano inaczej) traktują 2 kolory jako równe, jeśli wszystkie ich wartości czerwonego, zielonego, niebieskiego i alfa różnią się o maksymalnie 1e-5.

Przykład (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();
 }
 // ...

Przykład (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;
}
// ...

Przykład (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('');
};

// ...
Pola
red

float

Ilość czerwonego koloru jako wartość z przedziału [0, 1].
green

float

Ilość zielonego koloru jako wartość przedziału [0, 1].
blue

float

Ilość niebieskiego koloru jako wartość z przedziału [0, 1].
alpha

FloatValue

Część tego koloru, która powinna zostać zastosowana do piksela. Oznacza to, że końcowy kolor w pikselach jest określony za pomocą tego równania:

pixel color = alpha * (this color) + (1.0 - alpha) * (background color)

Oznacza to, że wartość 1,0 odpowiada jednolitym kolorowi, a wartość 0,0 – kolorowi całkowicie przezroczystemu. Wykorzystuje komunikat opakowany, a nie prosty zmiennoprzecinkowy element skalarny, dzięki czemu można odróżnić wartość domyślną od nieskonfigurowanej wartości. Jeśli ten obiekt koloru zostanie pominięty, będzie on renderowany jako jednolity kolor (jak gdyby wartość alfa miała jednoznacznie przypisaną wartość 1,0).