geojs 1.6.5 → 1.6.6

package/geo.js

@@ -6360,6 +6360,10 @@ 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);
 /**
  * Create a new instance of class pixelmapFeature.
  *
@@ -6383,6 +6387,216 @@ 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) {
+      if (!m_this._preparePixelmap()) {
+        return;
+      }
+
+      prepared = true;
+    }
+
+    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);
 
@@ -21986,8 +22200,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.
@@ -22060,12 +22272,8 @@ 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;
+      s_init = this._init;
   this.featureType = 'pixelmap';
   /**
    * Get/Set position accessor.
@@ -22102,7 +22310,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();
@@ -22110,31 +22318,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.
    *
@@ -22156,46 +22339,57 @@ 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.
+   * Update.
    *
-   * @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.
+   * @returns {this}
    */
 
 
-  this.pointSearch = function (geo, gcs) {
-    if (m_quadFeature && m_info) {
-      var result = m_quadFeature.pointSearch(geo, gcs);
+  this._update = function () {
+    s_update.call(m_this);
 
-      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 (m_this.buildTime().timestamp() <= m_this.dataTime().timestamp() || m_this.updateTime().timestamp() < m_this.timestamp()) {
+      m_this._build();
+    }
 
-        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;
+    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.
    *
@@ -22210,12 +22404,12 @@ var pixelmapFeature = function pixelmapFeature(arg) {
      * 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) {
@@ -22226,19 +22420,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);
           }
@@ -22247,7 +22441,7 @@ var pixelmapFeature = function pixelmapFeature(arg) {
 
 
           if (m_this.style.get('url')() === src) {
-            m_info = undefined;
+            m_this.m_info = undefined;
 
             m_this._computePixelmap();
           }
@@ -22255,7 +22449,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);
           }
@@ -22267,199 +22461,15 @@ 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();
-    return m_this;
-  };
   /**
    * Initialize.
    *
@@ -24419,7 +24429,8 @@ var quadFeature = function quadFeature(arg) {
 
           if (coordbasis) {
             extra[quad.idx] = {
-              basis: coordbasis
+              basis: coordbasis,
+              _quad: quad
             };
           }
         }
@@ -26017,7 +26028,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "07bea0c1a0c68aece32ca33afaeed257361803e3";
+module.exports = "c554b05bdeb079f7ebd7d317e44a885f9a93710f";
 
 /***/ }),
 
@@ -38481,7 +38492,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.6.5";
+module.exports = "1.6.6";
 
 /***/ }),
 
@@ -39244,8 +39255,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),
@@ -40195,6 +40208,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__) {
 
@@ -41134,6 +41280,209 @@ 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,
+      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);
+
+      if (result.index.length === 1 && result.extra && result.extra[result.index[0]].basis && result.extra[result.index[0]]._quad && result.extra[result.index[0]]._quad.image) {
+        var img = result.extra[result.index[0]]._quad.image;
+        var basis = result.extra[result.index[0]].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');
+
+    if (!m_lookupTable) {
+      m_lookupTable = lookupTable2D();
+      m_lookupTable.setTextureUnit(1);
+    }
+
+    var clrLen = Math.max(1, data.length);
+    var maxWidth = m_lookupTable.maxWidth();
+
+    if (clrLen > maxWidth && clrLen % maxWidth) {
+      clrLen += maxWidth - clrLen % maxWidth;
+    }
+
+    var colors = new Uint8Array(clrLen * 4);
+    data.forEach(function (d, 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 = 0;
+
+      for (; idx < colors.length; idx += 1) {
+        if (colors[idx] !== oldcolors[idx]) {
+          break;
+        }
+      }
+
+      if (idx === colors.length) {
+        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_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);
+      };
+
+      m_quadFeature.style({
+        image: m_this.m_srcImage,
+        position: m_this.style.get('position')
+      }).data([{}]).draw();
+    }
+  };
+  /**
+   * 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);
+
+  return this;
+};
+
+inherit(webgl_pixelmapFeature, pixelmapFeature); // Now register it
+
+registerFeature('webgl', 'pixelmap', webgl_pixelmapFeature);
+module.exports = webgl_pixelmapFeature;
+
+/***/ }),
+
 /***/ 5675:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
@@ -42498,7 +42847,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;
@@ -42523,6 +42872,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]);
@@ -42532,6 +42886,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 */
@@ -42708,6 +43067,11 @@ 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) {
@@ -42824,6 +43188,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.
    */
@@ -93906,6 +94305,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) {