Package google.type

Indice

• Color (messaggio)
• LatLng (messaggio)

Colore

Rappresenta un colore nello spazio colore RGBA. Questa rappresentazione è progettata per semplificare la conversione da e verso le rappresentazioni dei colori in varie lingue rispetto alla compattezza. Ad esempio, i campi di questa rappresentazione possono essere forniti in modo semplice al costruttore di "java.awt.Color" in Java, possono essere forniti in modo semplice al metodo "+colorWithRed:green:blue:alpha " di UIColor in iOS e, con un po' di lavoro, possono essere facilmente formattati in una stringa "rgba()" CSS anche in JavaScript.

Nota: questo proto non contiene informazioni sullo spazio colore assoluto da utilizzare per interpretare il valore RGB (ad es. sRGB, Adobe RGB, DCI-P3, BT.2020 e così via). Per impostazione predefinita, le applicazioni DEVONO utilizzare lo spazio colore sRGB.

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

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

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

// ...

Campi
red	float La quantità di rosso nel colore come valore nell'intervallo [0, 1].
green	float La quantità di verde nel colore come valore nell'intervallo [0, 1].
blue	float La quantità di blu nel colore come valore nell'intervallo [0, 1].
alpha	FloatValue La frazione di questo colore da applicare al pixel. ovvero il colore finale del pixel è definito dall'equazione: colore pixel = alpha * (questo colore) + (1.0 - alpha) * (colore di sfondo) Ciò significa che un valore pari a 1,0 corrisponde a un colore pieno, mentre un valore pari a 0,0 corrisponde a un colore completamente trasparente. Utilizza un messaggio wrapper anziché un semplice scalare float, in modo da poter distinguere tra un valore predefinito e il valore che viene annullato. Se omesso, questo oggetto colore deve essere visualizzato come un colore pieno (come se il valore alfa fosse stato fornito esplicitamente con un valore di 1.0).

LatLng

Un oggetto che rappresenta una coppia latitudine/longitudine. Questo valore è espresso come una coppia di numeri double che rappresentano i gradi di latitudine e longitudine. Se non diversamente specificato, deve essere conforme allo standard WGS84. I valori devono rientrare negli intervalli normalizzati.

Campi
latitude	double La latitudine in gradi. Deve essere compresa nell'intervallo [-90,0, +90,0].
longitude	double La longitudine in gradi. Deve essere compreso nell'intervallo [-180,0, +180,0].