v0.1.56

javascript/src/collection.js

@@ -195,14 +195,17 @@ ee.Collection.prototype.elementType = function() {
  *     receives an image or features and returns one. The function is called
  *     only once and the result is captured as a description, so it cannot
  *     perform imperative operations or rely on external state.
+ * @param {boolean=} opt_dropNulls If true, the mapped algorithm is allowed
+ *     to return nulls, and the elements for which it returns nulls will be
+ *     dropped.
  * @return {ee.Collection} The mapped collection.
  * @export
  */
-ee.Collection.prototype.map = function(algorithm) {
+ee.Collection.prototype.map = function(algorithm, opt_dropNulls) {
   var elementType = this.elementType();
   var withCast = function(e) { return algorithm(new elementType(e)); };
   return this.castInternal(ee.ApiFunction._call(
-      'Collection.map', this, withCast));
+      'Collection.map', this, withCast, opt_dropNulls));
 };
 
 

javascript/src/data.js

@@ -199,19 +199,32 @@ ee.data.reset = function() {
  *
  * This should be called before the EE library is initialized.
  *
+ * Note that if the user has not previously granted access to the application
+ * identified by the client ID, by default this will try to pop up a dialog
+ * window prompting the user to grant the required permission. However, this
+ * popup can be blocked by the browser. To avoid this, specify the
+ * opt_onImmediateFailed callback, and in it render an in-page login button,
+ * then call ee.data.authenticateViaPopup() from the click event handler of
+ * this button. This stops the browser from blocking the popup, as it is now the
+ * direct result of a user action.
+ *
  * @param {?string} clientId The application's OAuth client ID, or null to
  *     disable authenticated calls. This can be obtained through the Google
  *     Developers Console. The project must have a JavaScript origin that
  *     corresponds to the domain where the script is running.
  * @param {function()} success The function to call if authentication succeeded.
  * @param {function(string)=} opt_error The function to call if authentication
- *     failed, passed the error message.
+ *     failed, passed the error message. If authentication in immediate
+ *     (behind-the-scenes) mode fails and opt_onImmediateFailed is specified,
+ *     that function is called instead of opt_error.
  * @param {!Array<string>=} opt_extraScopes Extra OAuth scopes to request.
+ * @param {function()=} opt_onImmediateFailed The function to call if
+ *     automatic behind-the-scenes authentication fails. Defaults to
+ *     ee.data.authenticateViaPopup(), bound to the passed callbacks.
  * @export
- *
- * TODO(user): Figure out if we need to deal with pop-up blockers.
  */
-ee.data.authenticate = function(clientId, success, opt_error, opt_extraScopes) {
+ee.data.authenticate = function(
+    clientId, success, opt_error, opt_extraScopes, opt_onImmediateFailed) {
   // Remember the auth options.
   var scopes = [ee.data.AUTH_SCOPE_];
   if (opt_extraScopes) {
@@ -222,24 +235,46 @@ ee.data.authenticate = function(clientId, success, opt_error, opt_extraScopes) {
   ee.data.authScopes_ = scopes;
 
   // Start the authentication flow as soon as we have the auth library.
+  var onImmediateFailed = opt_onImmediateFailed || goog.partial(
+      ee.data.authenticateViaPopup, success, opt_error);
   if (goog.isObject(goog.global['gapi']) &&
       goog.isObject(goog.global['gapi']['auth']) &&
       goog.isFunction(goog.global['gapi']['auth']['authorize'])) {
-    ee.data.refreshAuthToken_(success, opt_error);
+    ee.data.refreshAuthToken_(success, opt_error, onImmediateFailed);
   } else {
     // The library is not loaded; load it now.
     var callbackName = goog.now().toString(36);
     while (callbackName in goog.global) callbackName += '_';
     goog.global[callbackName] = function() {
       delete goog.global[callbackName];
-      ee.data.refreshAuthToken_(success, opt_error);
+      ee.data.refreshAuthToken_(success, opt_error, onImmediateFailed);
     };
     goog.net.jsloader.load(
         ee.data.AUTH_LIBRARY_URL_ + '?onload=' + callbackName);
   }
 };
 
 
+/**
+ * Shows a popup asking for the user's permission. Should only be called if
+ * ee.data.authenticate() called its opt_onImmediateFailed argument in the past.
+ *
+ * May be blocked by pop-up blockers if called outside a user-initiated handler.
+ *
+ * @param {function()=} opt_success The function to call if authentication
+ *     succeeds.
+ * @param {function(string)=} opt_error The function to call if authentication
+ *     fails, passing the error message.
+ */
+ee.data.authenticateViaPopup = function(opt_success, opt_error) {
+  goog.global['gapi']['auth']['authorize']({
+    'client_id': ee.data.authClientId_,
+    'immediate': false,
+    'scope': ee.data.authScopes_.join(' ')
+  }, goog.partial(ee.data.handleAuthResult_, opt_success, opt_error));
+};
+
+
 /**
  * Sets the timeout length for asynchronous API requests.
  *
@@ -1005,45 +1040,56 @@ ee.data.send_ = function(path, params, opt_callback, opt_method) {
  *     succeeds.
  * @param {function(string)=} opt_error The function to call if token refresh
  *     fails, passing the error message.
+ * @param {function()=} opt_onImmediateFailed The function to call if
+ *     automatic behind-the-scenes authentication fails.
  * @private
  */
-ee.data.refreshAuthToken_ = function(opt_success, opt_error) {
+ee.data.refreshAuthToken_ = function(
+    opt_success, opt_error, opt_onImmediateFailed) {
   // Set up auth options.
   var authArgs = {
     'client_id': ee.data.authClientId_,
     'immediate': true,
     'scope': ee.data.authScopes_.join(' ')
   };
 
-  // A function to run when we get the authorization result.
-  var done = function(result) {
-    if (result['access_token']) {
-      ee.data.authToken_ = result['token_type'] + ' ' + result['access_token'];
-      // Set up a refresh timer. This is necessary because we cannot refresh
-      // synchronously, but since we want to allow synchronous API requests,
-      // something must ensure that the auth token is always valid.
-      setTimeout(ee.data.refreshAuthToken_, result['expires_in'] * 1000 / 2);
-      if (opt_success) opt_success();
-    } else if (opt_error) {
-      opt_error(result['error'] || 'Unknown error.');
-    }
-  };
-
   // Start the authorization flow, first trying immediate mode, which tries to
   // get the token behind the scenes, with no UI shown.
-  var authorize = goog.global['gapi']['auth']['authorize'];
-  authorize(authArgs, function(result) {
-    if (result['error'] == 'immediate_failed') {
-      // Could not auth invisibly. Auth using a dialog.
-      authArgs['immediate'] = false;
-      authorize(authArgs, done);
+  goog.global['gapi']['auth']['authorize'](authArgs, function(result) {
+    if (result['error'] == 'immediate_failed' && opt_onImmediateFailed) {
+      opt_onImmediateFailed();
     } else {
-      done(result);
+      ee.data.handleAuthResult_(opt_success, opt_error, result);
     }
   });
 };
 
 
+/**
+ * Handles the result of gapi.auth.authorize(), filling ee.data.authToken_ on
+ * success and setting up a refresh timeout.
+ *
+ * @param {function()|undefined} success The function to call if token refresh
+ *     succeeds.
+ * @param {function(string)|undefined} error The function to call if auth fails,
+ *     passing the error message.
+ * @param {Object} result The result object produced by gapi.auth.authorize().
+ * @private
+ */
+ee.data.handleAuthResult_ = function(success, error, result) {
+  if (result['access_token']) {
+    ee.data.authToken_ = result['token_type'] + ' ' + result['access_token'];
+    // Set up a refresh timer. This is necessary because we cannot refresh
+    // synchronously, but since we want to allow synchronous API requests,
+    // something must ensure that the auth token is always valid.
+    setTimeout(ee.data.refreshAuthToken_, result['expires_in'] * 1000 / 2);
+    if (success) success();
+  } else if (error) {
+    error(result['error'] || 'Unknown error.');
+  }
+};
+
+
 /**
  * Convert an object into a goog.Uri.QueryData.
  *

javascript/src/ee_api_js.externs.js

@@ -85,9 +85,10 @@ ee.Collection.prototype.limit = function(max, opt_property, opt_ascending) {
 };
 /**
  * @param {function ((Object|null)): (Object|null)} algorithm
+ * @param {boolean=} opt_dropNulls
  * @return {(ee.Collection|null)}
  */
-ee.Collection.prototype.map = function(algorithm) {
+ee.Collection.prototype.map = function(algorithm, opt_dropNulls) {
 };
 /**
  * @param {string} property
@@ -545,7 +546,7 @@ ee.Function.prototype.call = function(var_args) {
 };
 /**
  * @param {(Object|null)} geoJson
- * @param {(String|null)=} opt_proj
+ * @param {(ee.Projection|null)=} opt_proj
  * @param {boolean=} opt_geodesic
  * @return {?}
  * @extends {ee.ComputedObject}
@@ -554,72 +555,88 @@ ee.Function.prototype.call = function(var_args) {
 ee.Geometry = function(geoJson, opt_proj, opt_geodesic) {
 };
 /**
- * @param {(Array<Array<number>>|number)} coordinates
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
+ * @param {boolean=} opt_geodesic
+ * @param {(ee.ErrorMargin|null)=} opt_maxError
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.LineString = function(coordinates) {
+ee.Geometry.LineString = function(coords, opt_proj, opt_geodesic, opt_maxError) {
 };
 /**
- * @param {(Array<Array<number>>|number)} coordinates
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
+ * @param {boolean=} opt_geodesic
+ * @param {(ee.ErrorMargin|null)=} opt_maxError
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.LinearRing = function(coordinates) {
+ee.Geometry.LinearRing = function(coords, opt_proj, opt_geodesic, opt_maxError) {
 };
 /**
- * @param {(Array<Array<Array<number>>>|number)} coordinates
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
+ * @param {boolean=} opt_geodesic
+ * @param {(ee.ErrorMargin|null)=} opt_maxError
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.MultiLineString = function(coordinates) {
+ee.Geometry.MultiLineString = function(coords, opt_proj, opt_geodesic, opt_maxError) {
 };
 /**
- * @param {(Array<Array<number>>|number)} coordinates
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.MultiPoint = function(coordinates) {
+ee.Geometry.MultiPoint = function(coords, opt_proj) {
 };
 /**
- * @param {(Array<Array<Array<Array<number>>>>|number)} coordinates
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
+ * @param {boolean=} opt_geodesic
+ * @param {(ee.ErrorMargin|null)=} opt_maxError
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.MultiPolygon = function(coordinates) {
+ee.Geometry.MultiPolygon = function(coords, opt_proj, opt_geodesic, opt_maxError) {
 };
 /**
- * @param {(Array<number>|null|number)} coordsOrLon
- * @param {number=} opt_lat
+ * @param {Array<number>} coords
+ * @param {(ee.Projection|null)=} opt_proj
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.Point = function(coordsOrLon, opt_lat) {
+ee.Geometry.Point = function(coords, opt_proj) {
 };
 /**
- * @param {(Array<Array<Array<number>>>|number)} coordinates
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
+ * @param {boolean=} opt_geodesic
+ * @param {(ee.ErrorMargin|null)=} opt_maxError
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.Polygon = function(coordinates) {
+ee.Geometry.Polygon = function(coords, opt_proj, opt_geodesic, opt_maxError) {
 };
 /**
- * @param {(Array<number>|null|number)} coordsOrLon1
- * @param {number=} opt_lat1
- * @param {number=} opt_lon2
- * @param {number=} opt_lat2
+ * @param {(Array|null)} coords
+ * @param {(ee.Projection|null)=} opt_proj
+ * @param {boolean=} opt_geodesic
+ * @param {(ee.ErrorMargin|null)=} opt_maxError
  * @return {?}
  * @extends {ee.Geometry}
  * @constructor
  */
-ee.Geometry.Rectangle = function(coordsOrLon1, opt_lat1, opt_lon2, opt_lat2) {
+ee.Geometry.Rectangle = function(coords, opt_proj, opt_geodesic, opt_maxError) {
 };
 /**
  * @return {string}
@@ -745,7 +762,18 @@ ee.InitState.READY;
  */
 ee.List = function(list) {
 };
-ee.MapLayerOverlay;
+/**
+ * @param {string} url
+ * @param {string} mapId
+ * @param {string} token
+ * @param {(Object|null)} init
+ * @extends {goog.events.EventTarget}
+ * @implements {goog.disposable.IDisposable}
+ * @implements {goog.events.Listenable}
+ * @constructor
+ */
+ee.MapLayerOverlay = function(url, mapId, token, init) {
+};
 /**
  * @param {(google.maps.Point|null)} coord
  * @param {number} zoom
@@ -766,6 +794,14 @@ ee.MapLayerOverlay.prototype.releaseTile = function(tileDiv) {
  */
 ee.MapLayerOverlay.prototype.setOpacity = function(opacity) {
 };
+/**
+ * @extends {goog.events.EventTarget}
+ * @implements {goog.disposable.IDisposable}
+ * @implements {goog.events.Listenable}
+ * @constructor
+ */
+ee.MapTileManager = function() {
+};
 ee.Number;
 /**
  * @param {boolean=} opt_isCompound
@@ -816,9 +852,10 @@ ee.data;
  * @param {function (): ?} success
  * @param {function (string): ?=} opt_error
  * @param {Array<string>=} opt_extraScopes
+ * @param {function (): ?=} opt_onImmediateFailed
  * @return {undefined}
  */
-ee.data.authenticate = function(clientId, success, opt_error, opt_extraScopes) {
+ee.data.authenticate = function(clientId, success, opt_error, opt_extraScopes, opt_onImmediateFailed) {
 };
 /**
  * @param {string} taskId

javascript/src/examples/ImageCollection/ModisCloudMasking.js

@@ -30,7 +30,7 @@ var getQABits = function(image, start, end, newName) {
 var maskEmptyPixels = function(image) {
   // Find pixels that had observations.
   var withObs = image.select('num_observations_1km').gt(0);
-  return image.mask(withObs);
+  return image.mask(image.mask().and(withObs));
 };
 
 // A function to mask out cloudy pixels.
@@ -40,7 +40,7 @@ var maskClouds = function(image) {
   // Get the internal_cloud_algorithm_flag bit.
   var internalCloud = getQABits(QA, 10, 10, 'internal_cloud_algorithm_flag');
   // Return an image masking out cloudy areas.
-  return image.mask(internalCloud.eq(0));
+  return image.mask(image.mask().and(internalCloud.eq(0)));
 };
 
 // Start with an image collection for a 1 month period.