geojs 1.6.3 → 1.7.0

package/geo.js

@@ -221,7 +221,7 @@ var annotation = function annotation(type, args) {
   /**
    * Get or set the name of this annotation.
    *
-   * @param {string|undefined} arg If `undefined`, return the name, otherwise
+   * @param {string|undefined} [arg] If `undefined`, return the name, otherwise
    *    change it.  When setting the name, the value is trimmed of
    *    whitespace.  The name will not be changed to an empty string.
    * @returns {this|string} The current name or this annotation.
@@ -398,7 +398,7 @@ var annotation = function annotation(type, args) {
   /**
    * Get or set the state of this annotation.
    *
-   * @param {string|undefined} arg If `undefined`, return the state,
+   * @param {string|undefined} [arg] If `undefined`, return the state,
    *    otherwise change it.  This should be one of the
    *    {@link geo.annotation.state} values.
    * @returns {this|string} The current state or this annotation.
@@ -466,7 +466,7 @@ var annotation = function annotation(type, args) {
    */
 
 
-  this.processAction = function () {
+  this.processAction = function (evt) {
     return undefined;
   };
   /**
@@ -1309,8 +1309,8 @@ var annotation = function annotation(type, args) {
  *
  * @param {object} m_this The current annotation instance.
  * @param {function} s_actions The parent actions method.
- * @param {string} [state] The state to return actions for.  Defaults to
- *    the current state.
+ * @param {string|undefined} state The state to return actions for.  Defaults
+ *    to the current state.
  * @param {string} name The name of this annotation.
  * @param {Array} originalArgs arguments to original call
  * @returns {geo.actionRecord[]} A list of actions.
@@ -1365,7 +1365,7 @@ function continuousVerticesProcessAction(m_this, evt, name) {
   }
 
   var cpp = layer.options('continuousPointProximity');
-  var cpc = layer.options('continuousPointColinearity');
+  var cpc = layer.options('continuousPointCollinearity');
   var ccp = layer.options('continuousCloseProximity');
 
   if (cpp || cpp === 0) {
@@ -1381,7 +1381,7 @@ function continuousVerticesProcessAction(m_this, evt, name) {
     var dist = layer.displayDistance(vertices[vertices.length - 2], null, evt.mouse.map, 'display');
 
     if (dist && dist > cpp) {
-      // combine nearly colinear points
+      // combine nearly collinear points
       if (vertices.length >= (m_this._lastClickVertexCount || 1) + 3) {
         var d01 = layer.displayDistance(vertices[vertices.length - 3], null, vertices[vertices.length - 2], null),
             d12 = dist,
@@ -1429,6 +1429,11 @@ function continuousVerticesProcessAction(m_this, evt, name) {
  *    rectangle in edit mode.
  */
 
+/*
+ * @typedef {object} geo.rectangleAnnotation.subspec
+ * @typedef {geo.annotation.spec | geo.rectangleAnnotation.subspec} geo.rectangleAnnotation.spec
+ */
+
 /**
  * Rectangle annotation class.
  *
@@ -2894,9 +2899,9 @@ var textFeature = __webpack_require__(9757);
  * @property {number} [continuousPointProximity=5] The minimum distance in
  *   display coordinates (pixels) between two adjacent points when dragging
  *   to create an annotation.  `false` disables continuous drawing mode.
- * @property {number} [continuousPointColinearity=1.0deg] The minimum angle
+ * @property {number} [continuousPointCollinearity=1.0deg] The minimum angle
  *   between a series of three points when dragging to not interpret them as
- *   colinear.  Only applies if `continuousPointProximity` is not `false`.
+ *   collinear.  Only applies if `continuousPointProximity` is not `false`.
  * @property {number} [continuousCloseProximity=10] The minimum distance in
  *   display coordinates (pixels) to close a polygon or end drawing a line when
  *   dragging to create an annotation.  `false` never closes at the end of a
@@ -3048,8 +3053,8 @@ var annotationLayer = function annotationLayer(arg) {
     // continuous drawing modes.
     continuousPointProximity: 5,
     // in radians, minimum angle between continuous points to interpret them as
-    // being coliner
-    continuousPointColinearity: 1.0 * Math.PI / 180,
+    // being collinear
+    continuousPointCollinearity: 1.0 * Math.PI / 180,
     continuousCloseProximity: 10,
     // in pixels, 0 is exact
     finalPointProximity: 10,
@@ -3348,7 +3353,7 @@ var annotationLayer = function annotationLayer(arg) {
    * @param {geo.annotation} annotation The annotation to add.
    * @param {string|geo.transform|null} [gcs] `undefined` to use the interface
    *    gcs, `null` to use the map gcs, or any other transform.
-   * @param {boolean} update If `false`, don't update the layer after adding
+   * @param {boolean} [update] If `false`, don't update the layer after adding
    *    the annotation.
    * @returns {this} The current layer.
    * @fires geo.event.annotation.add_before
@@ -3388,7 +3393,7 @@ var annotationLayer = function annotationLayer(arg) {
    * Remove an annotation from the layer.
    *
    * @param {geo.annotation} annotation The annotation to remove.
-   * @param {boolean} update If `false`, don't update the layer after removing
+   * @param {boolean} [update] If `false`, don't update the layer after removing
    *    the annotation.
    * @returns {boolean} `true` if an annotation was removed.
    * @fires geo.event.annotation.remove
@@ -3602,7 +3607,7 @@ var annotationLayer = function annotationLayer(arg) {
    * Return the current set of annotations as a geojson object.  Alternately,
    * add a set of annotations from a geojson object.
    *
-   * @param {string|objectFile} [geojson] If present, add annotations based on
+   * @param {string|object|File} [geojson] If present, add annotations based on
    *    the given geojson object.  If `undefined`, return the current
    *    annotations as geojson.  This may be a JSON string, a javascript
    *    object, or a File object.
@@ -4830,7 +4835,7 @@ var camera = function camera(spec) {
    * Project a vector from world space into viewport (display) space.  The
    * resulting vector always has the last component (`w`) equal to 1.
    *
-   * @param {vec2|vec3|vec4} point The point in world coordinates.
+   * @param {vec3|vec4} point The point in world coordinates.
    * @returns {vec4} The point in display coordinates.
    */
 
@@ -4849,7 +4854,7 @@ var camera = function camera(spec) {
    * Project a vector from viewport (display) space into world space.  The
    * resulting vector always has the last component (`w`) equal to 1.
    *
-   * @param {vec2|vec3|vec4} point The point in display coordinates.
+   * @param {vec3|vec4} point The point in display coordinates.
    * @returns {vec4} The point in world space coordinates.
    */
 
@@ -5162,7 +5167,7 @@ var camera = function camera(spec) {
   /**
    * Represent a glmatrix as a pretty-printed string.
    * @param {mat4} mat A 4 x 4 matrix.
-   * @param {number} prec The number of decimal places.
+   * @param {number} [prec] The number of decimal places.
    * @returns {string}
    */
 
@@ -5230,7 +5235,7 @@ var camera = function camera(spec) {
 };
 /**
  * Supported projection types.
- * @enum
+ * @enum {boolean}
  */
 
 
@@ -5241,7 +5246,7 @@ camera.projection = {
 /**
  * Default camera clipping bounds.  Some features and renderers may rely on the
  * far clip value being more positive than the near clip value.
- * @enum
+ * @enum {number}
  */
 
 camera.clipbounds = {
@@ -6355,6 +6360,29 @@ var inherit = __webpack_require__(5699);
 var registerFeature = (__webpack_require__(4647).registerFeature);
 
 var pixelmapFeature = __webpack_require__(6374);
+
+var geo_event = __webpack_require__(5108);
+
+var util = __webpack_require__(4634);
+/**
+ * Pixelmap feature information record.
+ *
+ * @typedef {object} geo.pixelmapFeature.info
+ * @property {number} width The width of the source image.
+ * @property {number} height The width of the source image.
+ * @property {CanvasRenderingContext2D} context The HTMLCanvasElement context
+ *    used for handling the pixelmap.
+ * @property {ImageData} imageData The context's image data.
+ * @property {number[]} indices An array, one per pixel, of the index value in
+ *    the image.  This decodes the pixel value to the corresponding integer.
+ * @property number} area The number of pixels in the image.  This is
+ *    `width * height`.
+ * @property {object[]} mappedColors This has one entry for each distinct index
+ *    value.  Each entry has `first` and `last` with the first and last pixel
+ *    locations where that index occurs.  Note that last is the inclusive value
+ *    of the location (so its maximum possible value is `size - 1`).
+ */
+
 /**
  * Create a new instance of class pixelmapFeature.
  *
@@ -6378,6 +6406,219 @@ var canvas_pixelmapFeature = function canvas_pixelmapFeature(arg) {
   var object = __webpack_require__(3160);
 
   object.call(this);
+  var m_quadFeature,
+      s_exit = this._exit,
+      m_this = this;
+  /**
+   * If the specified coordinates are in the rendered quad, use the basis
+   * information from the quad to determine the pixelmap index value so that it
+   * can be included in the `found` results.
+   *
+   * @param {geo.geoPosition} geo Coordinate.
+   * @param {string|geo.transform|null} [gcs] Input gcs.  `undefined` to use
+   *    the interface gcs, `null` to use the map gcs, or any other transform.
+   * @returns {geo.feature.searchResult} An object with a list of features and
+   *    feature indices that are located at the specified point.
+   */
+
+  this.pointSearch = function (geo, gcs) {
+    if (m_quadFeature && m_this.m_info) {
+      var result = m_quadFeature.pointSearch(geo, gcs);
+
+      if (result.index.length === 1 && result.extra && result.extra[result.index[0]].basis) {
+        var basis = result.extra[result.index[0]].basis,
+            x,
+            y,
+            idx;
+        x = Math.floor(basis.x * m_this.m_info.width);
+        y = Math.floor(basis.y * m_this.m_info.height);
+
+        if (x >= 0 && x < m_this.m_info.width && y >= 0 && y < m_this.m_info.height) {
+          idx = m_this.m_info.indices[y * m_this.m_info.width + x];
+          result = {
+            index: [idx],
+            found: [m_this.data()[idx]]
+          };
+          return result;
+        }
+      }
+    }
+
+    return {
+      index: [],
+      found: []
+    };
+  };
+  /**
+   * Compute information for this pixelmap image.  It is wasteful to call this
+   * if the pixelmap has already been prepared (it is invalidated by a change
+   * in the image).
+   *
+   * @returns {geo.pixelmapFeature.info}
+   */
+
+
+  this._preparePixelmap = function () {
+    var i, idx, pixelData;
+
+    if (!util.isReadyImage(m_this.m_srcImage)) {
+      return;
+    }
+
+    m_this.m_info = {
+      width: m_this.m_srcImage.naturalWidth,
+      height: m_this.m_srcImage.naturalHeight,
+      canvas: document.createElement('canvas')
+    };
+    m_this.m_info.canvas.width = m_this.m_info.width;
+    m_this.m_info.canvas.height = m_this.m_info.height;
+    m_this.m_info.context = m_this.m_info.canvas.getContext('2d');
+    m_this.m_info.context.drawImage(m_this.m_srcImage, 0, 0);
+    m_this.m_info.imageData = m_this.m_info.context.getImageData(0, 0, m_this.m_info.canvas.width, m_this.m_info.canvas.height);
+    pixelData = m_this.m_info.imageData.data;
+    m_this.m_info.indices = new Array(pixelData.length / 4);
+    m_this.m_info.area = pixelData.length / 4;
+    m_this.m_info.mappedColors = {};
+
+    for (i = 0; i < pixelData.length; i += 4) {
+      idx = pixelData[i] + (pixelData[i + 1] << 8) + (pixelData[i + 2] << 16);
+      m_this.m_info.indices[i / 4] = idx;
+
+      if (!m_this.m_info.mappedColors[idx]) {
+        m_this.m_info.mappedColors[idx] = {
+          first: i / 4
+        };
+      }
+
+      m_this.m_info.mappedColors[idx].last = i / 4;
+    }
+
+    return m_this.m_info;
+  };
+  /**
+   * Given the loaded pixelmap image, create a canvas the size of the image.
+   * Compute a color for each distinct index and recolor the canvas based on
+   * these colors, then draw the resultant image as a quad.
+   *
+   * @fires geo.event.pixelmap.prepared
+   */
+
+
+  this._computePixelmap = function () {
+    var data = m_this.data() || [],
+        colorFunc = m_this.style.get('color'),
+        i,
+        idx,
+        lastidx,
+        color,
+        pixelData,
+        indices,
+        mappedColors,
+        updateFirst,
+        updateLast = -1,
+        update,
+        prepared;
+
+    if (!m_this.m_info) {
+      m_this.indexModified(undefined, 'clear');
+
+      if (!m_this._preparePixelmap()) {
+        return;
+      }
+
+      prepared = true;
+    }
+
+    m_this.indexModified(undefined, 'clear');
+    mappedColors = m_this.m_info.mappedColors;
+    updateFirst = m_this.m_info.area;
+
+    for (idx in mappedColors) {
+      if (mappedColors.hasOwnProperty(idx)) {
+        color = colorFunc(data[idx], +idx) || {};
+        color = [(color.r || 0) * 255, (color.g || 0) * 255, (color.b || 0) * 255, color.a === undefined ? 255 : color.a * 255];
+        mappedColors[idx].update = !mappedColors[idx].color || mappedColors[idx].color[0] !== color[0] || mappedColors[idx].color[1] !== color[1] || mappedColors[idx].color[2] !== color[2] || mappedColors[idx].color[3] !== color[3];
+
+        if (mappedColors[idx].update) {
+          mappedColors[idx].color = color;
+          updateFirst = Math.min(mappedColors[idx].first, updateFirst);
+          updateLast = Math.max(mappedColors[idx].last, updateLast);
+        }
+      }
+    }
+    /* If nothing was updated, we are done */
+
+
+    if (updateFirst >= updateLast) {
+      return;
+    }
+    /* Update only the extent that has changed */
+
+
+    pixelData = m_this.m_info.imageData.data;
+    indices = m_this.m_info.indices;
+
+    for (i = updateFirst; i <= updateLast; i += 1) {
+      idx = indices[i];
+
+      if (idx !== lastidx) {
+        lastidx = idx;
+        color = mappedColors[idx].color;
+        update = mappedColors[idx].update;
+      }
+
+      if (update) {
+        pixelData[i * 4] = color[0];
+        pixelData[i * 4 + 1] = color[1];
+        pixelData[i * 4 + 2] = color[2];
+        pixelData[i * 4 + 3] = color[3];
+      }
+    }
+    /* Place the updated area into the canvas */
+
+
+    m_this.m_info.context.putImageData(m_this.m_info.imageData, 0, 0, 0, Math.floor(updateFirst / m_this.m_info.width), m_this.m_info.width, Math.ceil((updateLast + 1) / m_this.m_info.width));
+    /* If we haven't made a quad feature, make one now.  The quad feature needs
+     * to have the canvas capability. */
+
+    if (!m_quadFeature) {
+      m_quadFeature = m_this.layer().createFeature('quad', {
+        selectionAPI: false,
+        gcs: m_this.gcs(),
+        visible: m_this.visible(undefined, true)
+      });
+      m_this.dependentFeatures([m_quadFeature]);
+      m_quadFeature.style({
+        image: m_this.m_info.canvas,
+        position: m_this.style.get('position')
+      }).data([{}]).draw();
+    }
+    /* If we prepared the pixelmap and rendered it, send a prepared event */
+
+
+    if (prepared) {
+      m_this.geoTrigger(geo_event.pixelmap.prepared, {
+        pixelmap: m_this
+      });
+    }
+  };
+  /**
+   * Destroy.  Deletes the associated quadFeature.
+   *
+   * @returns {this}
+   */
+
+
+  this._exit = function () {
+    if (m_quadFeature && m_this.layer()) {
+      m_this.layer().deleteFeature(m_quadFeature);
+      m_quadFeature = null;
+      m_this.dependentFeatures([]);
+    }
+
+    s_exit();
+    return m_this;
+  };
 
   this._init(arg);
 
@@ -7400,7 +7641,7 @@ var choroplethFeature = function choroplethFeature(arg) {
   /**
    * Add a geojson polygon feature to the current layer.
    *
-   * @param {geojsonFeature} feature A geojson parsed feature.
+   * @param {geo.geojsonFeature} feature A geojson parsed feature.
    * @param {geo.geoColor} fillColor The fill color for the feature.
    * @returns {geo.polygonFeature}
    */
@@ -7814,11 +8055,12 @@ var domRenderer = function domRenderer(arg) {
   /**
    * Initialize.
    *
+   * @param {object} [arg] Optional arguments.
    * @returns {this}
    */
 
 
-  this._init = function () {
+  this._init = function (arg) {
     var layer = m_this.layer().node();
 
     if (!m_this.canvas() && layer && layer.length) {
@@ -9767,7 +10009,7 @@ var featureLayer = function featureLayer(arg) {
   /**
    * Get/Set drawables.
    *
-   * @param {geo.feature[]} val A list of features, or unspecified to return
+   * @param {geo.feature[]} [val] A list of features, or unspecified to return
    *    the current feature list.  If a list is provided, features are added or
    *    removed as needed.
    * @returns {geo.feature[]|this} The current features associated with the
@@ -10351,7 +10593,7 @@ var object = __webpack_require__(3737);
  * Object specification for a fileReader.
  *
  * @typedef {object} geo.fileReader.spec
- * @property {geo.featureLayer} layer The target feature layer.
+ * @property {geo.featureLayer} [layer] The target feature layer.
  */
 
 /**
@@ -10360,7 +10602,7 @@ var object = __webpack_require__(3737);
  * @class
  * @alias geo.fileReader
  * @extends geo.object
- * @param {geo.fileReader.spec} arg
+ * @param {geo.fileReader.spec} [arg]
  * @returns {geo.fileReader}
  */
 
@@ -11838,7 +12080,8 @@ var tile = __webpack_require__(8418);
  * @property {object} [size] The size of each tile.
  * @property {number} [size.x=256] Width in pixels.
  * @property {number} [size.y=256] Height in pixels.
- * @property {string} [crossDomain='anonymous'] Image CORS attribute.
+ * @property {string} [crossDomain='anonymous'] Image CORS attribute.  This is
+ *   used for the `crossorigin` property when loading images.
  */
 
 /**
@@ -12031,6 +12274,7 @@ module.exports = $.extend({
   polygonFeature: __webpack_require__(4343),
   quadFeature: __webpack_require__(5017),
   pixelmapFeature: __webpack_require__(6374),
+  pixelmapLayer: __webpack_require__(809),
   renderer: __webpack_require__(3234),
   sceneObject: __webpack_require__(5358),
   textFeature: __webpack_require__(9757),
@@ -13002,7 +13246,7 @@ var isolineFeature = function isolineFeature(arg) {
    * the generated labels.  The viewport calculation is conservative, as the
    * map could be rotated, changed size, or have other modifications.
    *
-   * @returns {exit}
+   * @returns {this}
    */
 
 
@@ -13610,7 +13854,7 @@ var layer = function layer(arg) {
   /**
    * Get root node of the layer.
    *
-   * @returns {div}
+   * @returns {HTMLDivElement}
    */
 
 
@@ -13938,11 +14182,13 @@ var layer = function layer(arg) {
    * Update layer.
    *
    * This is a stub that should be subclassed.
+   *
+   * @param {object} [arg] An object, possibly with an ``event`` key and value.
    * @returns {this}
    */
 
 
-  this._update = function () {
+  this._update = function (arg) {
     return m_this;
   };
   /**
@@ -14617,9 +14863,9 @@ var lineFeature = function lineFeature(arg) {
    *
    * @param {array} data A new data array.
    * @param {number} [tolerance] The maximum variation allowed in map.gcs
-   *    units.  A value of zero will only remove perfectly colinear points.  If
-   *    not specified, this is set to a half display pixel at the map's current
-   *    zoom level.
+   *    units.  A value of zero will only remove perfectly collinear points.
+   *    If not specified, this is set to a half display pixel at the map's
+   *    current zoom level.
    * @param {function} [posFunc=this.style.get('position')] The function to
    *    get the position of each vertex.
    * @param {function} [lineFunc=this.style.get('line')] The function to get
@@ -15357,7 +15603,7 @@ var map = function map(arg) {
    * view center.  Rotation mostly ignores `clampBoundsX`, as the behavior
    * feels peculiar otherwise.
    *
-   * @param {number} rotation Absolute angle in radians (positive is
+   * @param {number} [rotation] Absolute angle in radians (positive is
    *    clockwise).
    * @param {object} [origin] If specified, rotate about this origin.
    * @param {geo.geoPosition} origin.geo The gcs coordinates of the
@@ -15715,7 +15961,7 @@ var map = function map(arg) {
    *    coordinate to convert.
    * @param {string|geo.transform|null} [gcs] Output gcs.  `undefined` to use
    *    the interface gcs, `null` to use the map gcs, or any other transform.
-   * @returns {geo.geoPosition|geoPosition[]} GCS space coordinates.
+   * @returns {geo.geoPosition|geo.geoPosition[]} GCS space coordinates.
    */
 
 
@@ -15857,11 +16103,12 @@ var map = function map(arg) {
   /**
    * Initialize the map.
    *
+   * @param {object} [arg] Optional arguments.
    * @returns {this} The map object.
    */
 
 
-  this._init = function () {
+  this._init = function (arg) {
     if (m_node === undefined || m_node === null) {
       throw new Error('Map require DIV node');
     }
@@ -16228,7 +16475,7 @@ var map = function map(arg) {
         m_center = m_this.gcsToWorld({
           x: p[0],
           y: p[1]
-        }, null, true, true);
+        }, null);
         m_this.zoom(p[2], m_transition.zoomOrigin, true);
       }
 
@@ -16468,7 +16715,7 @@ var map = function map(arg) {
    * @param {number} rotation The requested rotation in clockwise radians.
    * @param {string|geo.transform|null} [gcs] `undefined` to use the interface
    *    gcs, `null` to use the map gcs, or any other transform.
-   * @param {boolean} ignoreDiscreteZoom If `true`, ignore the `discreteZoom`
+   * @param {boolean} [ignoreDiscreteZoom] If `true`, ignore the `discreteZoom`
    *    option when determining the new view.
    * @param {boolean} [ignoreClampBounds] If `true` and `clampBoundsX` or
    *    `clampBoundsY` is set, allow the bounds to be less clamped.
@@ -16720,11 +16967,11 @@ var map = function map(arg) {
    * @param {boolean|null} [opts.attribution=null] If `null` or unspecified,
    *    include the attribution only if all layers are used.  If false, never
    *    include the attribution.  If `true`, always include it.
-   * @param {HTMLObject[]|string[]} [opts.html] A list of additional HTML
+   * @param {HTMLElement[]|string[]} [opts.html] A list of additional HTML
    *    elements, selectors, or jQuery elements to render on top of the map.
    *    These are rendered in order, with the last one topmost.
-   * @returns {deferred} A jQuery Deferred object.  The done function receives
-   *    either a data URL or an `HTMLCanvasElement` with the result.
+   * @returns {jQueryDeferred} A jQuery Deferred object.  The done function
+   *    receives either a data URL or an `HTMLCanvasElement` with the result.
    * @fires geo.event.screenshot.ready
    */
 
@@ -16933,7 +17180,7 @@ var map = function map(arg) {
   /**
    * Return the nearest valid zoom level to the requested zoom.
    * @param {number} zoom A zoom level to adjust to current settings
-   * @param {boolean} ignoreDiscreteZoom If `true`, ignore the `discreteZoom`
+   * @param {boolean} [ignoreDiscreteZoom] If `true`, ignore the `discreteZoom`
    *    option when determining the new view.
    * @returns {number} The zoom level clamped to the allowed zoom range and
    *    with other settings applied.
@@ -16977,10 +17224,11 @@ var map = function map(arg) {
    * Draw a layer image to a canvas context.  The layer's opacity and transform
    * are applied.  This is used as part of making a screenshot.
    *
-   * @param {context} context The 2d canvas context to draw into.
+   * @param {CanvasRenderingContext2D} context The 2d canvas context to draw
+   *    into.
    * @param {number} opacity The opacity in the range [0, 1].
    * @param {object} elem A jQuery element that might have a transform.
-   * @param {HTMLImageObject} img The image or canvas to draw to the canvas.
+   * @param {HTMLImageElement} img The image or canvas to draw to the canvas.
    * @param {string} [mixBlendMode] the mix-blend-mode used to add this layer.
    * @private
    */
@@ -17188,12 +17436,12 @@ var map = function map(arg) {
    * Return a valid rotation angle.
    *
    * @param {number} rotation Proposed rotation.
-   * @param {boolean} ignoreRotationFunc If truthy and rotations are allowed,
+   * @param {boolean} [ignoreRotationFunc] If truthy and rotations are allowed,
    *    allow any rotation.  Otherwise, the rotation is passed through the
    *    `allowRotation` function.
-   * @param {boolean} noRangeLimit If falsy, ensure that the rotation is in the
-   *    range [0, 2*PI).  If it is very close to zero, it is snapped to zero.
-   *    If true, the rotation can have any value.
+   * @param {boolean} [noRangeLimit] If falsy, ensure that the rotation is in
+   *    the range [0, 2*PI).  If it is very close to zero, it is snapped to
+   *    zero.  If true, the rotation can have any value.
    * @returns {number} the validated rotation
    * @private
    */
@@ -19851,26 +20099,26 @@ var mapInteractor = function mapInteractor(args) {
    *    map in pixels relative to the map's div.
    * @param {geo.screenPosition} [options.center] The position of a touch
    *    event center relative to the window.
-   * @param {string} [button] One of `left`, `middle`, or `right` for mouse
-   *    events.
-   * @param {string} [modifiers] A space-separated list of metakeys that are
-   *    down on mouse events.
-   * @param {geo.screenPosition} [wheelDelta] The amount the wheel moved in
-   *    both directions for wheel events.  One step is often 20 units of
-   *    vement.
-   * @param {number} [wheelMode] The wheel delta mode.  See
+   * @param {string} [options.button] One of `left`, `middle`, or `right` for
+   *    mouse events.
+   * @param {string} [options.modifiers] A space-separated list of metakeys
+   *    that are down on mouse events.
+   * @param {geo.screenPosition} [options.wheelDelta] The amount the wheel
+   *    moved in both directions for wheel events.  One step is often 20 units
+   *    of movement.
+   * @param {number} [options.wheelMode] The wheel delta mode.  See
    *    https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent .
-   * @param {boolean} [touch] `truthy` if this is a touch event.
-   * @param {number} [rotation] Touch event rotation in degrees.
-   * @param {number} [scale] Touch event scale.  Initial events should have a
-   *    scale of 1; subsequent events should increase or decrease this to
-   *    simulate spread and pinch actions.
-   * @param {number[]} [pointers] A list of pointer numbers involved in a
-   *    touch event.  Pointers are number from one up, so `[1]` is the first
+   * @param {boolean} [options.touch] `truthy` if this is a touch event.
+   * @param {number} [options.rotation] Touch event rotation in degrees.
+   * @param {number} [options.scale] Touch event scale.  Initial events should
+   *    have a scale of 1; subsequent events should increase or decrease this
+   *    to simulate spread and pinch actions.
+   * @param {number[]} [options.pointers] A list of pointer numbers involved in
+   *    a touch event.  Pointers are number from one up, so `[1]` is the first
    *    touch point, `[1, 2]` are two touch points, and `[2]` is when the first
    *    point was released but the second is still touching.
-   * @param {string} [pointerType] `mouse` if this is a mouse action rather
-   *    than a touch action.
+   * @param {string} [options.pointerType] `mouse` if this is a mouse action
+   *    rather than a touch action.
    * @returns {mapInteractor}
    */
 
@@ -20505,7 +20753,7 @@ markerFeature.capabilities = {
 markerFeature.primitiveShapes = pointFeature.primitiveShapes;
 /**
  * Marker symbols
- * @enum
+ * @enum {number}
  */
 
 markerFeature.symbols = {
@@ -20562,7 +20810,7 @@ markerFeature.symbols = {
 });
 /**
  * Marker scale modes
- * @enum
+ * @enum {number}
  */
 
 markerFeature.scaleMode = {
@@ -20602,7 +20850,7 @@ var feature = __webpack_require__(6837);
  * of these properties can be functions, which get passed `data`.
  *
  * @typedef {object} geo.meshFeature.meshSpec
- * @property {number[]|array.<number[]>} [elements] If specified, a list of
+ * @property {number[]|Array.<number[]>} [elements] If specified, a list of
  *      indices into the data array that form elements.  If this is an array of
  *      arrays, each subarray must have at least either 3 values for triangular
  *      elements or 4 values for square elements.  If this is a single array,
@@ -21600,6 +21848,8 @@ var quadFeature = __webpack_require__(5017);
  *   specified, use this as the layer opacity.
  * @property {string} [source] If specified, use the predefined tile source
  *   (see {@link geo.osmLayer.tileSources}).
+ * @property {string} [crossDomain='anonymous'] Image CORS attribute.  This is
+ *   used for the `crossorigin` property when loading images.
  */
 
 /**
@@ -21973,8 +22223,6 @@ var inherit = __webpack_require__(5699);
 
 var feature = __webpack_require__(6837);
 
-var geo_event = __webpack_require__(5108);
-
 var util = __webpack_require__(4634);
 /**
  * Pixelmap feature specification.
@@ -22003,25 +22251,6 @@ var util = __webpack_require__(4634);
  *   transformations for those two triangles.
  */
 
-/**
- * Pixelmap feature information record.
- *
- * @typedef {object} geo.pixelmapFeature.info
- * @property {number} width The width of the source image.
- * @property {number} height The width of the source image.
- * @property {context} context The HTMLCanvasElement context used for handling
- *    the pixelmap.
- * @property {ImageData} imageData The context's image data.
- * @property {number[]} indices An array, one per pixel, of the index value in
- *    the image.  This decodes the pixel value to the corresponding integer.
- * @property number} area The number of pixels in the image.  This is
- *    `width * height`.
- * @property {object[]} mappedColors This has one entry for each distinct index
- *    value.  Each entry has `first` and `last` with the first and last pixel
- *    locations where that index occurs.  Note that last is the inclusive value
- *    of the location (so its maximum possible value is `size - 1`).
- */
-
 /**
  * Create a new instance of class pixelmapFeature
  *
@@ -22047,12 +22276,9 @@ var pixelmapFeature = function pixelmapFeature(arg) {
    */
 
   var m_this = this,
-      m_quadFeature,
-      m_srcImage,
-      m_info,
       s_update = this._update,
-      s_init = this._init,
-      s_exit = this._exit;
+      m_modifiedIndexRange,
+      s_init = this._init;
   this.featureType = 'pixelmap';
   /**
    * Get/Set position accessor.
@@ -22089,7 +22315,7 @@ var pixelmapFeature = function pixelmapFeature(arg) {
     if (val === undefined) {
       return m_this.style('url');
     } else if (val !== m_this.style('url')) {
-      m_srcImage = m_info = undefined;
+      m_this.m_srcImage = m_this.m_info = undefined;
       m_this.style('url', val);
       m_this.dataTime().modified();
       m_this.modified();
@@ -22097,31 +22323,6 @@ var pixelmapFeature = function pixelmapFeature(arg) {
 
     return m_this;
   };
-  /**
-   * Get the maximum index value from the pixelmap.  This is a value present in
-   * the pixelmap.
-   *
-   * @returns {number} The maximum index value.
-   */
-
-
-  this.maxIndex = function () {
-    if (m_info) {
-      /* This isn't just m_info.mappedColors.length - 1, since there
-       * may be more data than actual indices. */
-      if (m_info.maxIndex === undefined) {
-        m_info.maxIndex = 0;
-
-        for (var idx in m_info.mappedColors) {
-          if (m_info.mappedColors.hasOwnProperty(idx)) {
-            m_info.maxIndex = Math.max(m_info.maxIndex, idx);
-          }
-        }
-      }
-
-      return m_info.maxIndex;
-    }
-  };
   /**
    * Get/Set color accessor.
    *
@@ -22143,46 +22344,101 @@ var pixelmapFeature = function pixelmapFeature(arg) {
     return m_this;
   };
   /**
-   * If the specified coordinates are in the rendered quad, use the basis
-   * information from the quad to determine the pixelmap index value so that it
-   * can be included in the `found` results.
+   * Mark that an index's data value (and hence its color) has changed without
+   * marking all of the data array as changed.  If this function is called
+   * without any parameters, it clears the tracked changes.
    *
-   * @param {geo.geoPosition} geo Coordinate.
-   * @param {string|geo.transform|null} [gcs] Input gcs.  `undefined` to use
-   *    the interface gcs, `null` to use the map gcs, or any other transform.
-   * @returns {geo.feature.searchResult} An object with a list of features and
-   *    feature indices that are located at the specified point.
+   * @param {number} [idx] The lowest data index that has changed.  If
+   *    `undefined`, return the current tracked changed range.
+   * @param {number|'clear'} [idx2] If an index was specified in `idx` and
+   *    this is specified, the highest index (inclusive) that has changed.  If
+   *    returning the tracked changed range and this is `clear`, clear the
+   *    tracked range.
+   * @returns {this|number[]} When returning a range, this is the lowest and
+   *    highest index values that have changed (inclusive), so their range is
+   *    `[0, data.length)`.
    */
 
 
-  this.pointSearch = function (geo, gcs) {
-    if (m_quadFeature && m_info) {
-      var result = m_quadFeature.pointSearch(geo, gcs);
+  this.indexModified = function (idx, idx2) {
+    if (idx === undefined) {
+      var range = m_modifiedIndexRange;
 
-      if (result.index.length === 1 && result.extra && result.extra[result.index[0]].basis) {
-        var basis = result.extra[result.index[0]].basis,
-            x,
-            y,
-            idx;
-        x = Math.floor(basis.x * m_info.width);
-        y = Math.floor(basis.y * m_info.height);
+      if (idx2 === 'clear') {
+        m_modifiedIndexRange = undefined;
+      }
 
-        if (x >= 0 && x < m_info.width && y >= 0 && y < m_info.height) {
-          idx = m_info.indices[y * m_info.width + x];
-          result = {
-            index: [idx],
-            found: [m_this.data()[idx]]
-          };
-          return result;
+      return range;
+    }
+
+    m_this.modified();
+
+    if (m_modifiedIndexRange === undefined) {
+      m_modifiedIndexRange = [idx, idx];
+    }
+
+    if (idx < m_modifiedIndexRange[0]) {
+      m_modifiedIndexRange[0] = idx;
+    }
+
+    if ((idx2 || idx) > m_modifiedIndexRange[1]) {
+      m_modifiedIndexRange[1] = idx2 || idx;
+    }
+
+    return m_this;
+  };
+  /**
+   * Update.
+   *
+   * @returns {this}
+   */
+
+
+  this._update = function () {
+    s_update.call(m_this);
+
+    if (m_this.buildTime().timestamp() <= m_this.dataTime().timestamp() || m_this.updateTime().timestamp() < m_this.timestamp()) {
+      m_this._build();
+    }
+
+    m_this.updateTime().modified();
+    return m_this;
+  };
+  /**
+   * Get the maximum index value from the pixelmap.  This is a value present in
+   * the pixelmap.
+   *
+   * @returns {number} The maximum index value.
+   */
+
+
+  this.maxIndex = function () {
+    if (m_this.m_info) {
+      /* This isn't just m_info.mappedColors.length - 1, since there
+       * may be more data than actual indices. */
+      if (m_this.m_info.maxIndex === undefined) {
+        m_this.m_info.maxIndex = 0;
+
+        for (var idx in m_this.m_info.mappedColors) {
+          if (m_this.m_info.mappedColors.hasOwnProperty(idx)) {
+            m_this.m_info.maxIndex = Math.max(m_this.m_info.maxIndex, idx);
+          }
         }
       }
-    }
 
-    return {
-      index: [],
-      found: []
-    };
+      return m_this.m_info.maxIndex;
+    }
   };
+  /**
+   * Given the loaded pixelmap image, create a canvas the size of the image.
+   * Compute a color for each distinct index and recolor the canvas based on
+   * these colors, then draw the resultant image as a quad.
+   *
+   * @fires geo.event.pixelmap.prepared
+   */
+
+
+  this._computePixelmap = function () {};
   /**
    * Build.  Fetches the image if necessary.
    *
@@ -22195,14 +22451,12 @@ var pixelmapFeature = function pixelmapFeature(arg) {
      * drawing a quad, which can trigger a full layer update, which in turn
      * checks if this feature is built.  Setting the build time avoids calling
      * this a second time. */
-    m_this.buildTime().modified();
-
-    if (!m_srcImage) {
+    if (!m_this.m_srcImage) {
       var src = m_this.style.get('url')();
 
       if (util.isReadyImage(src)) {
         /* we have an already loaded image, so we can just use it. */
-        m_srcImage = src;
+        m_this.m_srcImage = src;
 
         m_this._computePixelmap();
       } else if (src) {
@@ -22213,19 +22467,19 @@ var pixelmapFeature = function pixelmapFeature(arg) {
         if (src instanceof Image) {
           /* we have an unloaded image.  Hook to the load and error callbacks
            * so that when it is loaded we can use it. */
-          m_srcImage = src;
+          m_this.m_srcImage = src;
           prev_onload = src.onload;
           prev_onerror = src.onerror;
         } else {
           /* we were given a url, so construct a new image */
-          m_srcImage = new Image(); // Only set the crossOrigin parameter if this is going across origins.
+          m_this.m_srcImage = new Image(); // Only set the crossOrigin parameter if this is going across origins.
 
           if (src.indexOf(':') >= 0 && src.indexOf('/') === src.indexOf(':') + 1) {
-            m_srcImage.crossOrigin = m_this.style.get('crossDomain')() || 'anonymous';
+            m_this.m_srcImage.crossOrigin = m_this.style.get('crossDomain')() || 'anonymous';
           }
         }
 
-        m_srcImage.onload = function () {
+        m_this.m_srcImage.onload = function () {
           if (prev_onload) {
             prev_onload.apply(m_this, arguments);
           }
@@ -22234,7 +22488,7 @@ var pixelmapFeature = function pixelmapFeature(arg) {
 
 
           if (m_this.style.get('url')() === src) {
-            m_info = undefined;
+            m_this.m_info = undefined;
 
             m_this._computePixelmap();
           }
@@ -22242,7 +22496,7 @@ var pixelmapFeature = function pixelmapFeature(arg) {
           defer.resolve();
         };
 
-        m_srcImage.onerror = function () {
+        m_this.m_srcImage.onerror = function () {
           if (prev_onerror) {
             prev_onerror.apply(m_this, arguments);
           }
@@ -22254,197 +22508,14 @@ var pixelmapFeature = function pixelmapFeature(arg) {
         m_this.layer().addPromise(m_this);
 
         if (!(src instanceof Image)) {
-          m_srcImage.src = src;
+          m_this.m_srcImage.src = src;
         }
       }
-    } else if (m_info) {
+    } else if (m_this.m_info) {
       m_this._computePixelmap();
     }
 
-    return m_this;
-  };
-  /**
-   * Compute information for this pixelmap image.  It is wasteful to call this
-   * if the pixelmap has already been prepared (it is invalidated by a change
-   * in the image).
-   *
-   * @returns {geo.pixelmapFeature.info}
-   */
-
-
-  this._preparePixelmap = function () {
-    var i, idx, pixelData;
-
-    if (!util.isReadyImage(m_srcImage)) {
-      return;
-    }
-
-    m_info = {
-      width: m_srcImage.naturalWidth,
-      height: m_srcImage.naturalHeight,
-      canvas: document.createElement('canvas')
-    };
-    m_info.canvas.width = m_info.width;
-    m_info.canvas.height = m_info.height;
-    m_info.context = m_info.canvas.getContext('2d');
-    m_info.context.drawImage(m_srcImage, 0, 0);
-    m_info.imageData = m_info.context.getImageData(0, 0, m_info.canvas.width, m_info.canvas.height);
-    pixelData = m_info.imageData.data;
-    m_info.indices = new Array(pixelData.length / 4);
-    m_info.area = pixelData.length / 4;
-    m_info.mappedColors = {};
-
-    for (i = 0; i < pixelData.length; i += 4) {
-      idx = pixelData[i] + (pixelData[i + 1] << 8) + (pixelData[i + 2] << 16);
-      m_info.indices[i / 4] = idx;
-
-      if (!m_info.mappedColors[idx]) {
-        m_info.mappedColors[idx] = {
-          first: i / 4
-        };
-      }
-
-      m_info.mappedColors[idx].last = i / 4;
-    }
-
-    return m_info;
-  };
-  /**
-   * Given the loaded pixelmap image, create a canvas the size of the image.
-   * Compute a color for each distinct index and recolor the canvas based on
-   * these colors, then draw the resultant image as a quad.
-   *
-   * @fires geo.event.pixelmap.prepared
-   */
-
-
-  this._computePixelmap = function () {
-    var data = m_this.data() || [],
-        colorFunc = m_this.style.get('color'),
-        i,
-        idx,
-        lastidx,
-        color,
-        pixelData,
-        indices,
-        mappedColors,
-        updateFirst,
-        updateLast = -1,
-        update,
-        prepared;
-
-    if (!m_info) {
-      if (!m_this._preparePixelmap()) {
-        return;
-      }
-
-      prepared = true;
-    }
-
-    mappedColors = m_info.mappedColors;
-    updateFirst = m_info.area;
-
-    for (idx in mappedColors) {
-      if (mappedColors.hasOwnProperty(idx)) {
-        color = colorFunc(data[idx], +idx) || {};
-        color = [(color.r || 0) * 255, (color.g || 0) * 255, (color.b || 0) * 255, color.a === undefined ? 255 : color.a * 255];
-        mappedColors[idx].update = !mappedColors[idx].color || mappedColors[idx].color[0] !== color[0] || mappedColors[idx].color[1] !== color[1] || mappedColors[idx].color[2] !== color[2] || mappedColors[idx].color[3] !== color[3];
-
-        if (mappedColors[idx].update) {
-          mappedColors[idx].color = color;
-          updateFirst = Math.min(mappedColors[idx].first, updateFirst);
-          updateLast = Math.max(mappedColors[idx].last, updateLast);
-        }
-      }
-    }
-    /* If nothing was updated, we are done */
-
-
-    if (updateFirst >= updateLast) {
-      return;
-    }
-    /* Update only the extent that has changed */
-
-
-    pixelData = m_info.imageData.data;
-    indices = m_info.indices;
-
-    for (i = updateFirst; i <= updateLast; i += 1) {
-      idx = indices[i];
-
-      if (idx !== lastidx) {
-        lastidx = idx;
-        color = mappedColors[idx].color;
-        update = mappedColors[idx].update;
-      }
-
-      if (update) {
-        pixelData[i * 4] = color[0];
-        pixelData[i * 4 + 1] = color[1];
-        pixelData[i * 4 + 2] = color[2];
-        pixelData[i * 4 + 3] = color[3];
-      }
-    }
-    /* Place the updated area into the canvas */
-
-
-    m_info.context.putImageData(m_info.imageData, 0, 0, 0, Math.floor(updateFirst / m_info.width), m_info.width, Math.ceil((updateLast + 1) / m_info.width));
-    /* If we haven't made a quad feature, make one now.  The quad feature needs
-     * to have the canvas capability. */
-
-    if (!m_quadFeature) {
-      m_quadFeature = m_this.layer().createFeature('quad', {
-        selectionAPI: false,
-        gcs: m_this.gcs(),
-        visible: m_this.visible(undefined, true)
-      });
-      m_this.dependentFeatures([m_quadFeature]);
-      m_quadFeature.style({
-        image: m_info.canvas,
-        position: m_this.style.get('position')
-      }).data([{}]).draw();
-    }
-    /* If we prepared the pixelmap and rendered it, send a prepared event */
-
-
-    if (prepared) {
-      m_this.geoTrigger(geo_event.pixelmap.prepared, {
-        pixelmap: m_this
-      });
-    }
-  };
-  /**
-   * Update.
-   *
-   * @returns {this}
-   */
-
-
-  this._update = function () {
-    s_update.call(m_this);
-
-    if (m_this.buildTime().timestamp() <= m_this.dataTime().timestamp() || m_this.updateTime().timestamp() < m_this.timestamp()) {
-      m_this._build();
-    }
-
-    m_this.updateTime().modified();
-    return m_this;
-  };
-  /**
-   * Destroy.  Deletes the associated quadFeature.
-   *
-   * @returns {this}
-   */
-
-
-  this._exit = function () {
-    if (m_quadFeature && m_this.layer()) {
-      m_this.layer().deleteFeature(m_quadFeature);
-      m_quadFeature = null;
-      m_this.dependentFeatures([]);
-    }
-
-    s_exit();
+    m_this.buildTime().modified();
     return m_this;
   };
   /**
@@ -22486,6 +22557,13 @@ var pixelmapFeature = function pixelmapFeature(arg) {
 
     m_this.style(style);
     m_this.dataTime().modified();
+
+    if (arg.quadFeature) {
+      m_this.m_srcImage = true;
+
+      m_this._computePixelmap();
+    }
+
     return m_this;
   };
 
@@ -22511,13 +22589,182 @@ pixelmapFeature.create = function (layer, spec) {
 
 pixelmapFeature.capabilities = {
   /* core feature name -- support in any manner */
-  feature: 'pixelmap'
+  feature: 'pixelmap',
+
+  /* support for image-based lookup */
+  lookup: 'pixelmap.lookup'
 };
 inherit(pixelmapFeature, feature);
 module.exports = pixelmapFeature;
 
 /***/ }),
 
+/***/ 809:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var $ = __webpack_require__(5638);
+
+var inherit = __webpack_require__(5699);
+
+var tileLayer = __webpack_require__(1940);
+
+var registry = __webpack_require__(4647);
+
+var quadFeature = __webpack_require__(5017);
+
+var pixelmapFeature = __webpack_require__(6374);
+/**
+ * Object specification for a pixelmap layer.
+ *
+ * @typedef {geo.tileLayer.spec} geo.pixelmapLayer.spec
+ * @extends {geo.tileLayer.spec}
+ * @property {geo.geoColor|function} [color] The color that should be used
+ *   for each data element.  Data elements correspond to the indices in the
+ *   pixel map. If an index is larger than the number of data elements, it will
+ *   be transparent.  If there is more data than there are indices, it is
+ *   ignored.
+ * @property {object} [style] An optional style object that could contain
+ *   `color` or other style values.
+ * @property {array} [data] A new data array.
+ * @property {string} [crossDomain='anonymous'] Image CORS attribute.  This is
+ *   used for the `crossorigin` property when loading images.
+ */
+
+/**
+ * Create a new instance of pixelmapLayer.  This is a {@link geo.tileLayer} with
+ * an OSM url and attribution defaults and with the tiles centered on the
+ * origin.
+ *
+ * @class
+ * @alias geo.pixelmapLayer
+ * @extends geo.tileLayer
+ *
+ * @param {geo.pixelmapLayer.spec} [arg] Specification for the layer.
+ */
+
+
+var pixelmapLayer = function pixelmapLayer(arg) {
+  var imageTile = __webpack_require__(4665);
+
+  if (!(this instanceof pixelmapLayer)) {
+    return new pixelmapLayer(arg);
+  }
+
+  arg = arg || {};
+  arg = $.extend(true, {}, this.constructor.defaults, arg);
+  tileLayer.call(this, arg);
+  var s_init = this._init,
+      m_pixelmapFeature,
+      m_this = this;
+  /**
+   * Returns an instantiated imageTile object with the given indices.  This
+   * method always returns a new tile object.  Use `_getTileCached` to use
+   * the caching layer.
+   *
+   * @param {object} index The tile index.
+   * @param {number} index.x
+   * @param {number} index.y
+   * @param {number} index.level
+   * @param {object} source The tile index used for constructing the url.
+   * @param {number} source.x
+   * @param {number} source.y
+   * @param {number} source.level
+   * @returns {geo.tile}
+   */
+
+  this._getTile = function (index, source) {
+    var urlParams = source || index;
+    return imageTile({
+      index: index,
+      size: {
+        x: m_this._options.tileWidth,
+        y: m_this._options.tileHeight
+      },
+      queue: m_this._queue,
+      overlap: m_this._options.tileOverlap,
+      scale: m_this._options.tileScale,
+      url: m_this._options.url.call(m_this, urlParams.x, urlParams.y, urlParams.level || 0, m_this._options.subdomains),
+      crossDomain: m_this._options.crossDomain
+    });
+  };
+  /**
+   * Initialize.
+   *
+   * @returns {this} The current layer.
+   */
+
+
+  this._init = function () {
+    // Call super class init
+    s_init.apply(m_this, arguments);
+    var pixelmapArgs = {
+      quadFeature: m_this.features()[0]
+    };
+
+    if (arg.style) {
+      pixelmapArgs.style = arg.style;
+    }
+
+    if (arg.color) {
+      pixelmapArgs.color = arg.color;
+    }
+
+    m_pixelmapFeature = m_this.createFeature('pixelmap', pixelmapArgs);
+
+    if (arg.data) {
+      m_pixelmapFeature.data(arg.data);
+    }
+
+    m_this.style = m_pixelmapFeature.style;
+    m_this.data = m_pixelmapFeature.data;
+    m_this.indexModified = m_pixelmapFeature.indexModified;
+    var s_dataTimeModified = m_this.dataTime().modified;
+
+    m_this.dataTime().modified = function () {
+      m_pixelmapFeature.dataTime().modified();
+      return s_dataTimeModified();
+    };
+
+    ['modified', 'geoOn', 'geoOff', 'geoOnce'].forEach(function (funcName) {
+      var superFunc = m_this[funcName];
+
+      m_this[funcName] = function () {
+        m_pixelmapFeature[funcName].apply(this, arguments);
+        return superFunc.apply(this, arguments);
+      };
+    });
+    return m_this;
+  };
+
+  return m_this;
+};
+/**
+ * This object contains the default options used to initialize the
+ * pixelmapLayer.
+ */
+
+
+pixelmapLayer.defaults = $.extend({}, tileLayer.defaults, {
+  features: [quadFeature.capabilities.image, pixelmapFeature.capabilities.lookup],
+  tileOffset: function tileOffset(level) {
+    var s = Math.pow(2, level - 1) * 256;
+    return {
+      x: s,
+      y: s
+    };
+  },
+  url: ''
+});
+inherit(pixelmapLayer, tileLayer);
+/* By default, ask to support image quads.  If the user needs full
+ * reprojection, they will need to require the
+ * quadFeature.capabilities.imageFull feature */
+
+registry.registerLayer('pixelmap', pixelmapLayer, [quadFeature.capabilities.image]);
+module.exports = pixelmapLayer;
+
+/***/ }),
+
 /***/ 2557:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
@@ -23177,7 +23424,7 @@ pointFeature.capabilities = {
 };
 /**
  * Support primitive shapes
- * @enum
+ * @enum {string}
  */
 
 pointFeature.primitiveShapes = {
@@ -23903,9 +24150,9 @@ var polygonFeature = function polygonFeature(arg) {
    *
    * @param {array} data A new data array.
    * @param {number} [tolerance] The maximum variation allowed in map.gcs
-   *    units.  A value of zero will only remove perfectly colinear points.  If
-   *    not specified, this is set to a half display pixel at the map's current
-   *    zoom level.
+   *    units.  A value of zero will only remove perfectly collinear points.
+   *    If not specified, this is set to a half display pixel at the map's
+   *    current zoom level.
    * @param {function} [posFunc=this.style.get('position')] The function to
    *    get the position of each vertex.
    * @param {function} [polyFunc=this.style.get('polygon')] The function to
@@ -24406,7 +24653,8 @@ var quadFeature = function quadFeature(arg) {
 
           if (coordbasis) {
             extra[quad.idx] = {
-              basis: coordbasis
+              basis: coordbasis,
+              _quad: quad
             };
           }
         }
@@ -25099,7 +25347,7 @@ util.registerRenderer = function (name, func) {
  * @param {geo.layer} layer The layer associated with the renderer.
  * @param {HTMLCanvasElement} [canvas] A canvas object to share between
  *      renderers.
- * @param {object} options Options for the new renderer.
+ * @param {object} [options] Options for the new renderer.
  * @returns {geo.renderer|null} The new renderer or null if no such name is
  *      registered.
  */
@@ -25128,7 +25376,7 @@ util.createRenderer = function (name, layer, canvas, options) {
  *
  * @alias geo.checkRenderer
  * @param {string|null} name Name of the desired renderer.
- * @param {boolean} noFallback If truthy, don't recommend a fallback.
+ * @param {boolean} [noFallback] If truthy, don't recommend a fallback.
  * @returns {string|null|false} The name of the renderer that should be used
  *      or false if no valid renderer can be determined.
  */
@@ -26004,7 +26252,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "4c7a5260c6c4756f2cf461d00c9be82abaea01a7";
+module.exports = "1d12f116c34ea5a1423ecb767df24b2291e53b06";
 
 /***/ }),
 
@@ -27385,10 +27633,10 @@ var svgRenderer = function svgRenderer(arg) {
    * Create a new feature element from an object that describes the feature
    * attributes.  To be called from feature classes only.
    *
-   * @param {object} arg Options for the features.
+   * @param {object} arg
    * @param {string} arg.id A unique string identifying the feature.
    * @param {array} arg.data Array of data objects used in a d3 data method.
-   * @param {function} [aeg.dataIndex] A function that returns a unique id for
+   * @param {function} [arg.dataIndex] A function that returns a unique id for
    *    each data element.  This is passed to the data access function.
    * @param {object} arg.style An object with style values or functions.
    * @param {object} arg.attributes An object containing element attributes.
@@ -27401,7 +27649,7 @@ var svgRenderer = function svgRenderer(arg) {
    *    attributes and styles set when new.  If falsy, features always have
    *    attributes and styles updated.
    * @param {boolean} [arg.sortByZ] If truthy, sort features by the `d.zIndex`.
-   * @param {string} [parentId] If set, the group ID of the parent element.
+   * @param {string} [arg.parentId] If set, the group ID of the parent element.
    * @returns {this}
    */
 
@@ -28714,7 +28962,7 @@ var tileCache = function tileCache(options) {
    * Remove a tile from the cache.
    *
    * @param {string|geo.tile} tile The tile or its hash.
-   * @returns {booliean} `true` if a tile was removed.
+   * @returns {boolean} `true` if a tile was removed.
    */
 
 
@@ -29409,7 +29657,7 @@ var tileLayer = function tileLayer(arg) {
   /**
    * Returns a tile's bounds in a gcs.
    *
-   * @param {object|tile} indexOrTile Either a tile or an object with
+   * @param {object|geo.tile} indexOrTile Either a tile or an object with
    *    {x, y, level}` specifying a tile.
    * @param {string|geo.transform|null} [gcs] `undefined` to use the
    *    interface gcs, `null` to use the map gcs, or any other transform.
@@ -29578,7 +29826,7 @@ var tileLayer = function tileLayer(arg) {
    * @param {number} maxLevel The zoom level
    * @param {geo.geoBounds} bounds The map bounds
    * @param {boolean} sorted Return a sorted list
-   * @param {boolean} onlyIfChanged If the set of tiles have not changed
+   * @param {boolean} [onlyIfChanged] If the set of tiles have not changed
    *     (even if their desired order has), return undefined instead of an
    *     array of tiles.
    * @returns {geo.tile[]} An array of tile objects
@@ -29599,7 +29847,7 @@ var tileLayer = function tileLayer(arg) {
         changed = false,
         old,
         level,
-        minLevel = m_this._options.keepLower ? m_this._options.minLevel : maxLevel;
+        minLevel = m_this._options.keepLower ? m_this._options.minLevel : Math.max(maxLevel, m_this._options.minLevel);
 
     if (maxLevel < minLevel) {
       maxLevel = minLevel;
@@ -30112,7 +30360,7 @@ var tileLayer = function tileLayer(arg) {
    * origin.
    *
    * @param {object} pt A point in world space coordinates with `x` and `y`.
-   * @param {number|undefined} zoom If unspecified, use the map zoom.
+   * @param {number} [zoom] If unspecified, use the map zoom.
    * @returns {object} Local coordinates with `x` and `y`.
    */
 
@@ -30161,7 +30409,7 @@ var tileLayer = function tileLayer(arg) {
    * create the element if it doesn't already exist.
    *
    * @param {number} level The zoom level of the layer to fetch.
-   * @returns {DOM} The layer's DOM element.
+   * @returns {HTMLElement} The layer's DOM element.
    */
 
 
@@ -30518,8 +30766,8 @@ var tileLayer = function tileLayer(arg) {
    * @param {geo.geoBounds} [bounds] The view bounds (if unspecified, assume
    *      global bounds)
    * @param {number} bounds.level The zoom level the bounds are given as.
-   * @param {number} zoom Keep in bound tile at this zoom level.
-   * @param {boolean} doneLoading If true, allow purging additional tiles.
+   * @param {number} [zoom] Keep in bound tile at this zoom level.
+   * @param {boolean} [doneLoading] If true, allow purging additional tiles.
    * @returns {boolean}
    */
 
@@ -30539,7 +30787,7 @@ var tileLayer = function tileLayer(arg) {
       /* For tile layers that should only keep one layer, if loading is
        * finished, purge all but the current layer.  This is important for
        * semi-transparent layers. */
-      if ((doneLoading || m_this._isCovered(tile)) && zoom !== tile.index.level) {
+      if ((doneLoading || m_this._isCovered(tile)) && zoom !== tile.index.level && (zoom >= m_this._options.minLevel || tile.index.level !== m_this._options.minLevel)) {
         return true;
       }
     }
@@ -30632,9 +30880,9 @@ var tileLayer = function tileLayer(arg) {
   /**
    * Get or set the subdomains used for templating.
    *
-   * @param {string|list} [subdomains] A comma-separated list, a string of
+   * @param {string|string[]} [subdomains] A comma-separated list, a string of
    *      single character subdomains, or a list.
-   * @returns {string|list|this}
+   * @returns {string|string[]|this}
    */
 
 
@@ -30678,8 +30926,8 @@ var tileLayer = function tileLayer(arg) {
   /**
    * Get/Set visibility of the layer.
    *
-   * @param {boolean|undefined} val If unspecified, return the visibility,
-   *    otherwise set it.
+   * @param {boolean} [val] If unspecified, return the visibility, otherwise
+   *    set it.
    * @returns {boolean|this} Either the visibility (if getting) or the layer
    *    (if setting).
    */
@@ -30896,24 +31144,24 @@ var util = __webpack_require__(4634);
  * @extends geo.feature.spec
  * @property {geo.geoPosition|function} [position] Position of the data.
  *   Default is (data).
- * @property {float|function} [time] Time of the data.  Default is `(data).t`.
+ * @property {number|function} [time] Time of the data.  Default is `(data).t`.
  * @property {object|function} [track] Tracks from the data.  Default is
  *   (data).  Typically, the data is an array of tracks, each of which is an
  *   array of points, each of which has a position and time.  The position and
  *   time functions are called for each point as `position(trackPoint,
  *   pointIndex, trackEntry, trackEntryIndex)`.
- * @property {float|null} [startTime=null] Start time.  Used for styling.  If
+ * @property {number|null} [startTime=null] Start time.  Used for styling.  If
  *   `null`, this is the duration before the end time if `duration` is not
  *  `null` and the minimum time in any track if `duration` is `null`.
- * @property {float} [endTime=null] End time.  Used for styling and position of
- *   the track head.  If `null` and either of `startTime` or `duration` are
+ * @property {number} [endTime=null] End time.  Used for styling and position
+ *   of the track head.  If `null` and either of `startTime` or `duration` are
  *   `null`, this is the maximum time in any track.
- * @property {float} [duration=null] Duration between start and end times.
+ * @property {number} [duration=null] Duration between start and end times.
  *   Ignored if both start and end times are specified.
- * @property {float|function} [text] Text to use for the head of the track.  If
- *   specified, the track head is rendered as text.  If `undefined` a marker is
- *   used instead.  If `null` or an empty string (`''`), neither a marker nor
- *   text is used.
+ * @property {number|function} [text] Text to use for the head of the track.
+ *   If specified, the track head is rendered as text.  If `undefined` a marker
+ *   is used instead.  If `null` or an empty string (`''`), neither a marker
+ *   nor text is used.
  * @property {geo.trackFeature.styleSpec} [style] Style object with default
  *   style options.
  * @property {geo.lineFeature.styleSpec} [pastStyle] Style object with
@@ -31061,7 +31309,7 @@ var trackFeature = function trackFeature(arg) {
    * Calculate an interpolated position given a time.  If the time is outside
    * the range of a track, the first or last point is returned.
    *
-   * @param {float} time The time to compute a position array for.
+   * @param {number} time The time to compute a position array for.
    * @param {string|geo.transform|null} [gcs] `undefined` to use the feature
    *    gcs, `null` to use the map gcs, or any other transform.  This transform
    *    is used for the interpolation; the results are still in feature gcs.
@@ -31226,7 +31474,7 @@ var trackFeature = function trackFeature(arg) {
     m_tracks.trackFunc = m_this.style.get('track');
     m_tracks.textFunc = m_this.style.get('text');
     ['past', 'current', 'future'].forEach(function (key) {
-      m_lineFeatures[key].style(m_this[key + 'Style']()).style(m_this.style()).line(m_this.style('track')).gcs(m_this.gcs()).data(data).position(m_this._linePosition(key));
+      m_lineFeatures[key].style(m_this.style()).style(m_this[key + 'Style']()).line(m_this.style('track')).gcs(m_this.gcs()).data(data).position(m_this._linePosition(key));
     });
     var timeExtents = {};
     data.forEach(function (d, i) {
@@ -31562,11 +31810,11 @@ var trackFeature = function trackFeature(arg) {
   /**
    * Get/Set time accessor.
    *
-   * @param {float} [val] If not specified, return the current time accessor.
+   * @param {number} [val] If not specified, return the current time accessor.
    *    If specified, use this for the time accessor and return `this`.  If a
    *    function is given, this is called with `(vertexElement, vertexIndex,
    *    dataElement, dataIndex)`.
-   * @returns {float|function|this} The current time or this feature.
+   * @returns {number|function|this} The current time or this feature.
    */
 
 
@@ -31636,8 +31884,8 @@ var trackFeature = function trackFeature(arg) {
   /**
    * Get or set the start time.
    *
-   * @param {float|null} [val] If specified, the new start time.
-   * @returns {float|null|this} If set, the instance.  Otherwise, the current
+   * @param {number|null} [val] If specified, the new start time.
+   * @returns {number|null|this} If set, the instance.  Otherwise, the current
    *    start time value.
    */
 
@@ -31658,8 +31906,8 @@ var trackFeature = function trackFeature(arg) {
   /**
    * Get or set the end time.
    *
-   * @param {float|null} [val] If specified, the new end time.
-   * @returns {float|null|this} If set, the instance.  Otherwise, the current
+   * @param {number|null} [val] If specified, the new end time.
+   * @returns {number|null|this} If set, the instance.  Otherwise, the current
    *    end time value.
    */
 
@@ -31680,8 +31928,8 @@ var trackFeature = function trackFeature(arg) {
   /**
    * Get or set the duration.
    *
-   * @param {float|null} [val] If specified, the new duration.
-   * @returns {float|null|this} If set, the instance.  Otherwise, the current
+   * @param {number|null} [val] If specified, the new duration.
+   * @returns {number|null|this} If set, the instance.  Otherwise, the current
    *    duration.
    */
 
@@ -32305,11 +32553,12 @@ transform.lookup = function (projection) {
  *
  * @param {string} srcPrj The source projection.
  * @param {string} tgtPrj The destination projection.
- * @param {geoPosition|geoPosition[]|number[]} coordinates An array of
- *      coordinate objects.  These may be in object or array form, or a flat
- *      array.
- * @param {number} numberOfComponents For flat arrays, either 2 or 3.
- * @returns {geoPosition|geoPosition[]|number[]} The transformed coordinates.
+ * @param {geo.geoPosition|geo.geoPosition[]|number[]} coordinates An array of
+ *    coordinate objects.  These may be in object or array form, or a flat
+ *    array.
+ * @param {number} [numberOfComponents] For flat arrays, either 2 or 3.
+ * @returns {geo.geoPosition|geo.geoPosition[]|number[]} The transformed
+ *    coordinates.
  */
 
 
@@ -32398,10 +32647,10 @@ transform.transformCoordinates = function (srcPrj, tgtPrj, coordinates, numberOf
  * components per coordinate.  The array is modified in place.
  *
  * @param {transform} trans The transformation object.
- * @param {geoPosition[]|number[]} coordinates An array of coordinate
+ * @param {geo.geoPosition[]|number[]} coordinates An array of coordinate
  *      objects or a flat array.
  * @param {number} numberOfComponents For flat arrays, either 2 or 3.
- * @returns {geoPosition[]|number[]} The transformed coordinates
+ * @returns {geo.geoPosition[]|number[]} The transformed coordinates
  */
 
 
@@ -32723,8 +32972,6 @@ transform.affineInverse = function (def, coords) {
  * @param {object} [ellipsoid=proj4.WGS84] An object with at least `a` and one
  *    of `b`, `f`, or `rf` (1 / `f`) -- this works with  proj4 ellipsoid
  *    definitions.
- * @param {number} [maxIterations=100] Maximum number of iterations to use
- *    to test convergence.
  * @returns {number} The distance in meters (or whatever units the ellipsoid
  *    was specified in.
  */
@@ -32862,7 +33109,7 @@ module.exports = transform;
 /***/ }),
 
 /***/ 3762:
-/***/ (function() {
+/***/ (function(module) {
 
 /*
  * Type definitions for jsdoc.
@@ -33100,6 +33347,7 @@ module.exports = transform;
  *
  * @typedef {geo.polygonFlat|geo.polygonObject} geo.polygon
  */
+module.exports = {};
 
 /***/ }),
 
@@ -34655,7 +34903,7 @@ var sliderWidget = function sliderWidget(arg) {
      * Respond to a mouse event on the widget.
      *
      * @param {d3Event} evt The event on the widget.
-     * @param {boolean} trans Truthy for an animated transition.
+     * @param {boolean} [trans] Truthy for an animated transition.
      */
 
     function respond(evt, trans) {
@@ -35276,7 +35524,7 @@ var $ = __webpack_require__(5638);
  *
  * @param {geo.util.ClusterGroup} group The source cluster group
  * @param {number} zoom The zoom level of the current node
- * @param {object[]} children An array of ClusterTrees or point objects
+ * @param {object[]} [children] An array of ClusterTrees or point objects
  */
 
 
@@ -35410,8 +35658,8 @@ ClusterTree.prototype.coords = function () {
  * @class
  * @alias geo.util.ClusterGroup
  * @param {object} opts An options object
- * @param {number} maxZoom The maximum zoom level to calculate.
- * @param {number} radius Size of clustering at zoom 0 in point gcs.
+ * @param {number} [opts.maxZoom] The maximum zoom level to calculate.
+ * @param {number} [opts.radius] Size of clustering at zoom 0 in point gcs.
  */
 
 
@@ -35613,7 +35861,7 @@ var colorName = __webpack_require__(9552);
 /**
  * @typedef {object} geo.util.cssColorConversionRecord
  * @property {string} name The name of the color conversion.
- * @property {RegEx} regex A regex that, if it matches the color string, will
+ * @property {RegExp} regex A regex that, if it matches the color string, will
  *      cause the process function to be invoked.
  * @property {function} process A function that takes (`color`, `match`) with
  *      the original color string and the results of matching the regex using
@@ -36073,7 +36321,7 @@ var util = {
    * Check if an object an HTMLVideoElement element that is loaded.
    *
    * @param {object} vid An object that might be an HTMLVideoElement.
-   * @param {boolean} [allowFailedVideo] If `true`, an viedo element that has
+   * @param {boolean} [allowFailedVideo] If `true`, an video element that has
    *     a source and has failed to load is also considered 'ready' in the
    *     sense that it isn't expected to change to a better state.
    * @returns {boolean} `true` if this is a video that is ready.
@@ -36463,7 +36711,7 @@ var util = {
    * var map = geo.map($.extend(results.map, {clampZoom: false}));
    * map.createLayer('osm', results.layer);
    *
-   * @param {string} [node] DOM selector for the map container.
+   * @param {string?} node DOM selector for the map container.
    * @param {number} width Width of the whole map contents in pixels.
    * @param {number} height Height of the whole map contents in pixels.
    * @param {number} [tileWidth] If an osm or tile layer is going to be used,
@@ -36737,7 +36985,7 @@ var util = {
   /**
    * Determine if two line segments cross.  They are not considered crossing if
    * they share a vertex.  They are crossing if either of one segment's
-   * vertices are colinear with the other segment.
+   * vertices are collinear with the other segment.
    *
    * @param {geo.geoPosition} seg1pt1 One endpoint of the first segment.
    * @param {geo.geoPosition} seg1pt2 The other endpoint of the first segment.
@@ -36759,7 +37007,7 @@ var util = {
     }
     /* If the lines cross, the signed area of the triangles formed between one
      * segment and the other's vertices will have different signs.  By using
-     * > 0, colinear points are crossing. */
+     * > 0, collinear points are crossing. */
 
 
     if (util.triangleTwiceSignedArea2d(seg1pt1, seg1pt2, seg2pt1) * util.triangleTwiceSignedArea2d(seg1pt1, seg1pt2, seg2pt2) > 0 || util.triangleTwiceSignedArea2d(seg2pt1, seg2pt2, seg1pt1) * util.triangleTwiceSignedArea2d(seg2pt1, seg2pt2, seg1pt2) > 0) {
@@ -36806,7 +37054,7 @@ var util = {
    * @param {geo.geoPosition[]} pts A list of points forming the line or
    *    polygon.
    * @param {number} tolerance The maximum variation allowed.  A value of zero
-   *    will only remove perfectly colinear points.
+   *    will only remove perfectly collinear points.
    * @param {boolean} [closed] If true, this is a polygon rather than an open
    *    line.  In this case, it is possible to get back a single point.
    * @param {Array.<geo.geoPosition[]>?} [noCrossLines] A falsy value to allow
@@ -36966,7 +37214,7 @@ var util = {
    */
   escapeUnicodeHTML: function escapeUnicodeHTML(text) {
     return text.replace(/./g, function (k) {
-      var code = k.charCodeAt();
+      var code = k.charCodeAt(0);
 
       if (code < 127) {
         return k;
@@ -37033,7 +37281,7 @@ var util = {
    * stored as local base64 urls.
    *
    * @param {string} css The css to parse for urls.
-   * @param {jQuery.selector|DOMElement} styleElem The element that receivs
+   * @param {jQuery.selector|HTMLElement} styleElem The element that receives
    *    the css text after dereferencing or the DOM element that has style
    *    that will be updated.
    * @param {jQuery.Deferred} styleDefer A Deferred to resolve once
@@ -38140,7 +38388,7 @@ module.exports.restoreWebglRenderer = function () {
  *    unspecified, callback will be executed one final time after the last
  *    throttled-function call. (After the throttled-function has not been
  *    called for `delay` milliseconds, the internal counter is reset)
- * @param {function} callback A function to be executed after `delay`
+ * @param {function} [callback] A function to be executed after `delay`
  *    milliseconds. The `this` context and all arguments are passed through,
  *    as-is, to `callback` when the throttled-function is executed.
  * @param {function} [accumulator] A function to be executed (synchronously)
@@ -38468,7 +38716,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.6.3";
+module.exports = "1.7.0";
 
 /***/ }),
 
@@ -39231,8 +39479,10 @@ module.exports = {
   isolineFeature: __webpack_require__(9752),
   layer: __webpack_require__(5389),
   lineFeature: __webpack_require__(7390),
+  lookupTable2D: __webpack_require__(8672),
   markerFeature: __webpack_require__(1848),
   meshColored: __webpack_require__(5651),
+  pixelmapFeature: __webpack_require__(9685),
   pointFeature: __webpack_require__(5675),
   polygonFeature: __webpack_require__(2890),
   quadFeature: __webpack_require__(2182),
@@ -40182,6 +40432,139 @@ module.exports = webgl_lineFeature;
 
 /***/ }),
 
+/***/ 8672:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var inherit = __webpack_require__(5699);
+
+var timestamp = __webpack_require__(6618);
+
+var vgl = __webpack_require__(320);
+/**
+ * Switch to a specific texture unit.
+ *
+ * @param {vgl.renderState} renderState An object that contains the context
+ *   used for drawing.
+ * @param {number} textureUnit The number of the texture unit [0-15].
+ */
+
+
+function activateTextureUnit(renderState, textureUnit) {
+  if (textureUnit >= 0 && textureUnit <= 31) {
+    renderState.m_context.activeTexture(vgl.GL.TEXTURE0 + textureUnit);
+  } else {
+    throw Error('[error] Texture unit ' + textureUnit + ' is not supported');
+  }
+}
+/**
+ * Create a new instance of class webgl_lookupTable2D.
+ *
+ * @class
+ * @alias geo.webgl.lookupTable2D
+ * @param {object} arg Options object.
+ * @param {number} [arg.maxWidth] Maximum width to use for the texture.  If the
+ *   number of colors set is less than this, the texture is 1D.  If greater, it
+ *   will be a rectangle of maxWidth x whatever height is necessary.
+ * @param {number[]} [arg.colorTable] Initial color table for the texture.
+ *   This is of the form RGBARGBA... where each value is an integer on the
+ *   scale [0,255].
+ * @extends vgl.texture
+ * @returns {geo.webgl.lookupTable2D}
+ */
+
+
+var webgl_lookupTable2D = function webgl_lookupTable2D(arg) {
+  'use strict';
+
+  if (!(this instanceof webgl_lookupTable2D)) {
+    return new webgl_lookupTable2D(arg);
+  }
+
+  arg = arg || {};
+  vgl.texture.call(this);
+  var m_setupTimestamp = timestamp(),
+      m_maxWidth = arg.maxWidth || 4096,
+      m_colorTable = new Uint8Array([0, 0, 0, 0]),
+      m_colorTableOrig,
+      m_this = this;
+  /**
+   * Create lookup table, initialize parameters, and bind data to it.
+   *
+   * @param {vgl.renderState} renderState An object that contains the context
+   *   used for drawing.
+   */
+
+  this.setup = function (renderState) {
+    activateTextureUnit(renderState, m_this.textureUnit());
+    renderState.m_context.deleteTexture(m_this.m_textureHandle);
+    m_this.m_textureHandle = renderState.m_context.createTexture();
+    renderState.m_context.bindTexture(vgl.GL.TEXTURE_2D, m_this.m_textureHandle);
+    renderState.m_context.texParameteri(vgl.GL.TEXTURE_2D, vgl.GL.TEXTURE_MIN_FILTER, vgl.GL.NEAREST);
+    renderState.m_context.texParameteri(vgl.GL.TEXTURE_2D, vgl.GL.TEXTURE_MAG_FILTER, vgl.GL.NEAREST);
+    renderState.m_context.texParameteri(vgl.GL.TEXTURE_2D, vgl.GL.TEXTURE_WRAP_S, vgl.GL.CLAMP_TO_EDGE);
+    renderState.m_context.texParameteri(vgl.GL.TEXTURE_2D, vgl.GL.TEXTURE_WRAP_T, vgl.GL.CLAMP_TO_EDGE);
+    renderState.m_context.pixelStorei(vgl.GL.UNPACK_ALIGNMENT, 1);
+    renderState.m_context.pixelStorei(vgl.GL.UNPACK_FLIP_Y_WEBGL, true);
+    renderState.m_context.texImage2D(vgl.GL.TEXTURE_2D, 0, vgl.GL.RGBA, m_this.width, m_this.height, 0, vgl.GL.RGBA, vgl.GL.UNSIGNED_BYTE, m_colorTable);
+    renderState.m_context.bindTexture(vgl.GL.TEXTURE_2D, null);
+    m_setupTimestamp.modified();
+  };
+  /**
+   * Get/set color table.
+   *
+   * @param {number[]} [val] An array of RGBARGBA... integers on a scale
+   *   of [0, 255].  `undefined` to get the current value.
+   * @returns {number[]|this}
+   */
+
+
+  this.colorTable = function (val) {
+    if (val === undefined) {
+      return m_colorTableOrig;
+    }
+
+    m_colorTableOrig = val;
+
+    if (val.length < 4) {
+      val = [0, 0, 0, 0];
+    }
+
+    m_this.width = Math.min(m_maxWidth, val.length / 4);
+    m_this.height = Math.ceil(val.length / 4 / m_maxWidth);
+
+    if (!(val instanceof Uint8Array) || val.length !== m_this.width * m_this.height * 4) {
+      if (val.length < m_this.width * m_this.height * 4) {
+        val = val.concat(new Array(m_this.width * m_this.height * 4 - val.length).fill(0));
+      }
+
+      m_colorTable = new Uint8Array(val);
+    } else {
+      m_colorTable = val;
+    }
+
+    m_this.modified();
+    return m_this;
+  };
+  /**
+   * Get maxWidth value.
+   *
+   * @returns {number} The maxWidth of the texture used.
+   */
+
+
+  this.maxWidth = function () {
+    return m_maxWidth;
+  };
+
+  this.colorTable(arg.colorTable || []);
+  return this;
+};
+
+inherit(webgl_lookupTable2D, vgl.texture);
+module.exports = webgl_lookupTable2D;
+
+/***/ }),
+
 /***/ 1848:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
@@ -40296,7 +40679,7 @@ var webgl_markerFeature = function webgl_markerFeature(arg) {
   /**
    * Create and style the data needed to render the markers.
    *
-    @param {boolean} onlyStyle if true, use the existing geometry and just
+    @param {boolean} [onlyStyle] if true, use the existing geometry and just
    *    recalculate the style.
    */
 
@@ -41121,6 +41504,247 @@ module.exports = webgl_object;
 
 /***/ }),
 
+/***/ 9685:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var inherit = __webpack_require__(5699);
+
+var registerFeature = (__webpack_require__(4647).registerFeature);
+
+var pixelmapFeature = __webpack_require__(6374);
+
+var lookupTable2D = __webpack_require__(8672);
+
+var util = __webpack_require__(4634);
+/**
+ * Create a new instance of class webgl.pixelmapFeature.
+ *
+ * @class
+ * @alias geo.webgl.pixelmapFeature
+ * @extends geo.pixelmapFeature
+ * @param {geo.pixelmapFeature.spec} arg
+ * @returns {geo.webgl.pixelmapFeature}
+ */
+
+
+var webgl_pixelmapFeature = function webgl_pixelmapFeature(arg) {
+  'use strict';
+
+  if (!(this instanceof webgl_pixelmapFeature)) {
+    return new webgl_pixelmapFeature(arg);
+  }
+
+  pixelmapFeature.call(this, arg);
+
+  var object = __webpack_require__(7719);
+
+  object.call(this);
+
+  var vgl = __webpack_require__(320);
+
+  var fragmentShader = __webpack_require__(3953);
+
+  var m_quadFeature,
+      m_quadFeatureInit,
+      s_exit = this._exit,
+      m_lookupTable,
+      m_this = this;
+  /**
+   * If the specified coordinates are in the rendered quad, use the basis
+   * information from the quad to determine the pixelmap index value so that it
+   * can be included in the `found` results.
+   *
+   * @param {geo.geoPosition} geo Coordinate.
+   * @param {string|geo.transform|null} [gcs] Input gcs.  `undefined` to use
+   *    the interface gcs, `null` to use the map gcs, or any other transform.
+   * @returns {geo.feature.searchResult} An object with a list of features and
+   *    feature indices that are located at the specified point.
+   */
+
+  this.pointSearch = function (geo, gcs) {
+    if (m_quadFeature && m_this.m_info) {
+      var result = m_quadFeature.pointSearch(geo, gcs); // use the last index by preference, since for tile layers, this is the
+      // topmosttile
+
+      var idxIdx = result.index.length - 1;
+
+      for (; idxIdx >= 0; idxIdx -= 1) {
+        if (result.extra[result.index[idxIdx]]._quad && result.extra[result.index[idxIdx]]._quad.image) {
+          var img = result.extra[result.index[idxIdx]]._quad.image;
+          var basis = result.extra[result.index[idxIdx]].basis;
+          var x = Math.floor(basis.x * img.width);
+          var y = Math.floor(basis.y * img.height);
+          var canvas = document.createElement('canvas');
+          canvas.width = canvas.height = 1;
+          var context = canvas.getContext('2d');
+          context.drawImage(img, x, y, 1, 1, 0, 0, 1, 1);
+          var pixel = context.getImageData(0, 0, 1, 1).data;
+          var idx = pixel[0] + pixel[1] * 256 + pixel[2] * 256 * 256;
+          result = {
+            index: [idx],
+            found: [m_this.data()[idx]]
+          };
+          return result;
+        }
+      }
+    }
+
+    return {
+      index: [],
+      found: []
+    };
+  };
+  /**
+   * Given the loaded pixelmap image, create a texture for the colors and a
+   * quad that will use it.
+   */
+
+
+  this._computePixelmap = function () {
+    var data = m_this.data() || [],
+        colorFunc = m_this.style.get('color');
+    var indexRange = m_this.indexModified(undefined, 'clear');
+    var fullUpdate = m_this.dataTime().timestamp() >= m_this.buildTime().timestamp() || indexRange === undefined;
+
+    if (!m_lookupTable) {
+      m_lookupTable = lookupTable2D();
+      m_lookupTable.setTextureUnit(1);
+      fullUpdate = true;
+    }
+
+    var clrLen = Math.max(1, data.length);
+    var maxWidth = m_lookupTable.maxWidth();
+
+    if (clrLen > maxWidth && clrLen % maxWidth) {
+      clrLen += maxWidth - clrLen % maxWidth;
+    }
+
+    var colors;
+
+    if (!fullUpdate) {
+      colors = m_lookupTable.colorTable();
+      fullUpdate = colors.length !== clrLen * 4;
+      indexRange[0] = Math.max(0, indexRange[0]);
+      indexRange[1] = Math.min(data.length, indexRange[1] + 1);
+    }
+
+    if (fullUpdate) {
+      colors = new Uint8Array(clrLen * 4);
+      indexRange = [0, data.length];
+    }
+
+    for (var i = indexRange[0]; i < indexRange[1]; i += 1) {
+      var d = data[i];
+      var color = util.convertColor(colorFunc.call(m_this, d, i));
+      colors[i * 4] = color.r * 255;
+      colors[i * 4 + 1] = color.g * 255;
+      colors[i * 4 + 2] = color.b * 255;
+      colors[i * 4 + 3] = color.a === undefined ? 255 : color.a * 255;
+    }
+
+    m_this.m_info = {
+      colors: colors
+    }; // check if colors haven't changed
+
+    var oldcolors = m_lookupTable.colorTable();
+
+    if (oldcolors && oldcolors.length === colors.length) {
+      var idx = indexRange[0] * 4;
+
+      for (; idx < indexRange[1] * 4; idx += 1) {
+        if (colors[idx] !== oldcolors[idx]) {
+          break;
+        }
+      }
+
+      if (idx === indexRange[1] * 4) {
+        return;
+      }
+    }
+
+    m_lookupTable.colorTable(colors);
+    /* If we haven't made a quad feature, make one now */
+
+    if (!m_quadFeature) {
+      m_quadFeature = m_this.layer().createFeature('quad', {
+        selectionAPI: false,
+        gcs: m_this.gcs(),
+        visible: m_this.visible(undefined, true)
+      });
+      m_quadFeatureInit = false;
+    }
+
+    if (!m_quadFeatureInit) {
+      m_this.dependentFeatures([m_quadFeature]);
+      m_quadFeature.setShader('image_fragment', fragmentShader);
+
+      m_quadFeature._hookBuild = function (prog) {
+        var lutSampler = new vgl.uniform(vgl.GL.INT, 'lutSampler');
+        lutSampler.set(m_lookupTable.textureUnit());
+        prog.addUniform(lutSampler);
+        var lutWidth = new vgl.uniform(vgl.GL.INT, 'lutWidth');
+        lutWidth.set(m_lookupTable.width);
+        prog.addUniform(lutWidth);
+        var lutHeight = new vgl.uniform(vgl.GL.INT, 'lutHeight');
+        lutHeight.set(m_lookupTable.height);
+        prog.addUniform(lutHeight);
+      };
+
+      m_quadFeature._hookRenderImageQuads = function (renderState, quads) {
+        quads.forEach(function (quad) {
+          if (quad.image && quad.texture && !quad.texture.nearestPixel()) {
+            quad.texture.setNearestPixel(true);
+          }
+        });
+        m_lookupTable.bind(renderState, quads);
+      };
+
+      if (m_quadFeatureInit === false) {
+        m_quadFeature.style({
+          image: m_this.m_srcImage,
+          position: m_this.style.get('position')
+        }).data([{}]).draw();
+      }
+
+      m_quadFeatureInit = true;
+    }
+  };
+  /**
+   * Destroy.  Deletes the associated quadFeature.
+   *
+   * @returns {this}
+   */
+
+
+  this._exit = function () {
+    if (m_quadFeature && m_this.layer()) {
+      m_this.layer().deleteFeature(m_quadFeature);
+      m_quadFeature = null;
+      m_this.dependentFeatures([]);
+    }
+
+    s_exit();
+    return m_this;
+  };
+
+  if (arg.quadFeature) {
+    m_quadFeature = arg.quadFeature;
+  }
+
+  this._init(arg);
+
+  return this;
+};
+
+inherit(webgl_pixelmapFeature, pixelmapFeature); // Now register it
+
+var capabilities = {};
+capabilities[pixelmapFeature.capabilities.lookup] = true;
+registerFeature('webgl', 'pixelmap', webgl_pixelmapFeature, capabilities);
+module.exports = webgl_pixelmapFeature;
+
+/***/ }),
+
 /***/ 5675:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
@@ -41216,7 +41840,7 @@ var webgl_pointFeature = function webgl_pointFeature(arg) {
   /**
    * Create and style the data needed to render the points.
    *
-   * @param {boolean} onlyStyle if true, use the existing geometry and just
+   * @param {boolean} [onlyStyle] if true, use the existing geometry and just
    *    recalculate the style.
    */
 
@@ -42485,7 +43109,7 @@ var webgl_quadFeature = function webgl_quadFeature(arg) {
 
 
   this._build = function () {
-    var mapper, mat, prog, srctex, unicrop, unicropsource, geom, context;
+    var mapper, mat, prog, srctex, unicrop, unicropsource, geom, context, sampler2d;
 
     if (!m_this.position()) {
       return;
@@ -42510,6 +43134,11 @@ var webgl_quadFeature = function webgl_quadFeature(arg) {
       prog.addUniform(new vgl.projectionUniform('projectionMatrix'));
       prog.addUniform(new vgl.floatUniform('opacity', 1.0));
       prog.addUniform(new vgl.floatUniform('zOffset', 0.0));
+      /* Use texture unit 0 */
+
+      sampler2d = new vgl.uniform(vgl.GL.INT, 'sampler2d');
+      sampler2d.set(0);
+      prog.addUniform(sampler2d);
       context = m_this.renderer()._glContext();
       unicrop = new vgl.uniform(context.FLOAT_VEC2, 'crop');
       unicrop.set([1.0, 1.0]);
@@ -42519,6 +43148,11 @@ var webgl_quadFeature = function webgl_quadFeature(arg) {
       prog.addUniform(unicropsource);
       prog.addShader(vgl.getCachedShader(context.VERTEX_SHADER, context, vertexShaderImage));
       prog.addShader(vgl.getCachedShader(context.FRAGMENT_SHADER, context, fragmentShaderImage));
+
+      if (m_this._hookBuild) {
+        m_this._hookBuild(prog);
+      }
+
       mat.addAttribute(prog);
       mat.addAttribute(new vgl.blend());
       /* This is similar to vgl.planeSource */
@@ -42695,15 +43329,21 @@ var webgl_quadFeature = function webgl_quadFeature(arg) {
         h,
         quadw,
         quadh;
+
+    if (m_this._hookRenderImageQuads) {
+      m_this._hookRenderImageQuads(renderState, m_quads.imgQuads);
+    }
+
     context.bindBuffer(context.ARRAY_BUFFER, m_glBuffers.imgQuadsPosition);
     $.each(m_quads.imgQuads, function (idx, quad) {
       if (!quad.image) {
         return;
       }
 
-      quad.texture.bind(renderState);
+      quad.texture.bind(renderState); // only check if the context is out of memory when using modestly large
+      // textures.  The check is slow.
 
-      if (context.getError() === context.OUT_OF_MEMORY) {
+      if ((quad.image.width > 4096 || quad.image.height > 4096 || quad.image.width * quad.image.height > 4194304) && context.getError() === context.OUT_OF_MEMORY) {
         console.log('Insufficient GPU memory for texture');
       }
 
@@ -42811,6 +43451,41 @@ var webgl_quadFeature = function webgl_quadFeature(arg) {
 
     m_this.modified();
   };
+  /**
+   * Set the image or color vertex or fragment shader.
+   *
+   * @param {string} shaderType One of `image_vertex`, `image_fragment`,
+   *   `color_vertex`, or `color_fragment`.
+   * @param {string} shaderCode The shader program.
+   * @returns {this} The class instance on success, undefined in an unknown
+   *    shaderType was specified.
+   */
+
+
+  this.setShader = function (shaderType, shaderCode) {
+    switch (shaderType) {
+      case 'image_vertex':
+        vertexShaderImage = shaderCode;
+        break;
+
+      case 'image_fragment':
+        fragmentShaderImage = shaderCode;
+        break;
+
+      case 'color_vertex':
+        vertexShaderColor = shaderCode;
+        break;
+
+      case 'color_fragment':
+        fragmentShaderColor = shaderCode;
+        break;
+
+      default:
+        return;
+    }
+
+    return m_this;
+  };
   /**
    * Destroy.
    */
@@ -43524,6 +44199,8 @@ webglRenderer.supported = function () {
 
     try {
       canvas = document.createElement('canvas');
+      /** @type {WebGLRenderingContext} */
+
       ctx = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
       /* getSupportExtensions will throw an exception if the context isn't
        * really supported. */
@@ -93891,6 +94568,13 @@ module.exports = "/* contourFeature vertex shader */\n\n#ifdef GL_ES\n  precisio
 
 /***/ }),
 
+/***/ 3953:
+/***/ (function(module) {
+
+module.exports = "/* pixelmapFeature fragment shader */\n\nvarying highp vec2 iTextureCoord;\nuniform sampler2D sampler2d;\nuniform sampler2D lutSampler;\nuniform int lutWidth;\nuniform int lutHeight;\nuniform mediump float opacity;\nuniform highp vec2 crop;\n\nvoid main(void) {\n  if ((crop.s < 1.0 && iTextureCoord.s > crop.s) || (crop.t < 1.0 && 1.0 - iTextureCoord.t > crop.t)) {\n    discard;\n  }\n  // to add anti-aliasing, we would need to know the current pixel size\n  // (probably computed in the vertex shader) and then sample the base image at\n  // multiple points, then average the output color.\n  highp vec4 lutValue = texture2D(sampler2d, iTextureCoord);\n  highp vec2 lutCoord;\n  lutCoord.s = (\n    mod(\n      // add 0.5 to handle float imprecision\n      floor(lutValue.r * 255.0 + 0.5) +\n      floor(lutValue.g * 255.0 + 0.5) * 256.0,\n      float(lutWidth)\n    // center in pixel\n    ) + 0.5) / float(lutWidth);\n  // Our image is top-down, so invert the coordinate\n  lutCoord.t = 1.0 - (\n    floor(\n      (\n        // add 0.5 to handle float imprecision\n        floor(lutValue.r * 255.0 + 0.5) +\n        floor(lutValue.g * 255.0 + 0.5) * 256.0 +\n        floor(lutValue.b * 255.0 + 0.5) * 256.0 * 256.0\n        // We may want an option to use the alpha channel to allow more indices\n      ) / float(lutWidth)\n    // center in pixel\n    ) + 0.5) / float(lutHeight);\n  if (lutCoord.t < 0.0) {\n    discard;\n  }\n  mediump vec4 color = texture2D(lutSampler, lutCoord);\n\n  color.a *= opacity;\n  gl_FragColor = color;\n}\n"
+
+/***/ }),
+
 /***/ 1815:
 /***/ (function(module) {