@mapcatch/util 2.0.4 → 2.0.5-b

package/src/gl-operations/shaders/fragment/interpolateValue.js

@@ -1,137 +1,137 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#define TRANSPARENT vec4(0.0)
-
-#pragma glslify: computeColor = require(../util/computeColor.glsl)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-
-uniform int scaleLength;
-uniform int sentinelLength;
-uniform sampler2D scaleColormap;
-uniform sampler2D sentinelColormap;
-
-uniform float nodataValue;
-uniform sampler2D textureA;
-uniform sampler2D textureB;
-uniform bool littleEndian;
-uniform float interpolationFraction;
-
-uniform vec4 aboveColor;
-uniform vec4 belowColor;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-bool isSentinelValue(sampler2D sentinelColormap, int len, float value) {
-  for (int i = 0; i < SENTINEL_MAX_LENGTH; ++i) {
-    if (i == len) {
-      break;
-    }
-    float i_f = float(i);
-    float lenFloat = float(len);
-    float sentinelOffset = getTexelValue(sentinelColormap, vec2((i_f + 0.5) / lenFloat, 0.75), littleEndian);
-    if (isCloseEnough(sentinelOffset, value)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void main() {
-  if (interpolationFraction <= 0.0) {
-    float texelFloat = getTexelValue(textureA, vTexCoordA, littleEndian);
-    if (isCloseEnough(texelFloat, nodataValue)) {
-      discard;
-    }
-    gl_FragColor = computeColor(
-      texelFloat,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-  } else if (interpolationFraction >= 1.0) {
-    float texelFloat = getTexelValue(textureB, vTexCoordB, littleEndian);
-    if (isCloseEnough(texelFloat, nodataValue)) {
-      discard;
-    }
-    gl_FragColor = computeColor(
-      texelFloat,
-      scaleColormap,
-      sentinelColormap,
-      scaleLength,
-      sentinelLength,
-      littleEndian,
-      aboveColor,
-      belowColor
-    );
-  } else {
-    // retrieve and decode pixel value from both tiles
-    float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-    float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-    bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-    bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-    if (aIsNodata && bIsNodata) {
-      discard;
-    } else if (
-      aIsNodata
-      || bIsNodata
-      || scaleLength == 0
-      || isSentinelValue(sentinelColormap, sentinelLength, texelFloatA)
-      || isSentinelValue(sentinelColormap, sentinelLength, texelFloatB)
-    ) {
-      vec4 colorA = (
-        aIsNodata
-        ? TRANSPARENT
-        : computeColor(
-            texelFloatA,
-            scaleColormap,
-            sentinelColormap,
-            scaleLength,
-            sentinelLength,
-            littleEndian,
-            aboveColor,
-            belowColor
-          )
-      );
-      vec4 colorB = (
-        bIsNodata
-        ? TRANSPARENT
-        : computeColor(
-            texelFloatB,
-            scaleColormap,
-            sentinelColormap,
-            scaleLength,
-            sentinelLength,
-            littleEndian,
-            aboveColor,
-            belowColor
-          )
-      );
-      gl_FragColor = mix(colorA, colorB, interpolationFraction);
-    } else {
-      float interpolated = mix(texelFloatA, texelFloatB, interpolationFraction);
-      gl_FragColor = computeColor(
-        interpolated,
-        scaleColormap,
-        sentinelColormap,
-        scaleLength,
-        sentinelLength,
-        littleEndian,
-        aboveColor,
-        belowColor
-      );
-    }
-  }
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#define TRANSPARENT vec4(0.0)
+
+#pragma glslify: computeColor = require(../util/computeColor.glsl)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+
+uniform int scaleLength;
+uniform int sentinelLength;
+uniform sampler2D scaleColormap;
+uniform sampler2D sentinelColormap;
+
+uniform float nodataValue;
+uniform sampler2D textureA;
+uniform sampler2D textureB;
+uniform bool littleEndian;
+uniform float interpolationFraction;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+bool isSentinelValue(sampler2D sentinelColormap, int len, float value) {
+  for (int i = 0; i < SENTINEL_MAX_LENGTH; ++i) {
+    if (i == len) {
+      break;
+    }
+    float i_f = float(i);
+    float lenFloat = float(len);
+    float sentinelOffset = getTexelValue(sentinelColormap, vec2((i_f + 0.5) / lenFloat, 0.75), littleEndian);
+    if (isCloseEnough(sentinelOffset, value)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void main() {
+  if (interpolationFraction <= 0.0) {
+    float texelFloat = getTexelValue(textureA, vTexCoordA, littleEndian);
+    if (isCloseEnough(texelFloat, nodataValue)) {
+      discard;
+    }
+    gl_FragColor = computeColor(
+      texelFloat,
+      scaleColormap,
+      sentinelColormap,
+      scaleLength,
+      sentinelLength,
+      littleEndian,
+      aboveColor,
+      belowColor
+    );
+  } else if (interpolationFraction >= 1.0) {
+    float texelFloat = getTexelValue(textureB, vTexCoordB, littleEndian);
+    if (isCloseEnough(texelFloat, nodataValue)) {
+      discard;
+    }
+    gl_FragColor = computeColor(
+      texelFloat,
+      scaleColormap,
+      sentinelColormap,
+      scaleLength,
+      sentinelLength,
+      littleEndian,
+      aboveColor,
+      belowColor
+    );
+  } else {
+    // retrieve and decode pixel value from both tiles
+    float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
+    float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
+    bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+    bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
+    if (aIsNodata && bIsNodata) {
+      discard;
+    } else if (
+      aIsNodata
+      || bIsNodata
+      || scaleLength == 0
+      || isSentinelValue(sentinelColormap, sentinelLength, texelFloatA)
+      || isSentinelValue(sentinelColormap, sentinelLength, texelFloatB)
+    ) {
+      vec4 colorA = (
+        aIsNodata
+        ? TRANSPARENT
+        : computeColor(
+            texelFloatA,
+            scaleColormap,
+            sentinelColormap,
+            scaleLength,
+            sentinelLength,
+            littleEndian,
+            aboveColor,
+            belowColor
+          )
+      );
+      vec4 colorB = (
+        bIsNodata
+        ? TRANSPARENT
+        : computeColor(
+            texelFloatB,
+            scaleColormap,
+            sentinelColormap,
+            scaleLength,
+            sentinelLength,
+            littleEndian,
+            aboveColor,
+            belowColor
+          )
+      );
+      gl_FragColor = mix(colorA, colorB, interpolationFraction);
+    } else {
+      float interpolated = mix(texelFloatA, texelFloatB, interpolationFraction);
+      gl_FragColor = computeColor(
+        interpolated,
+        scaleColormap,
+        sentinelColormap,
+        scaleLength,
+        sentinelLength,
+        littleEndian,
+        aboveColor,
+        belowColor
+      );
+    }
+  }
+}
 `

package/src/gl-operations/shaders/fragment/multiAnalyze1Calc.js

@@ -1,36 +1,36 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-
-uniform sampler2D textureA;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-
-uniform float filterLowA;
-uniform float filterHighA;
-uniform float multiplierA;
-
-varying vec2 vTexCoord;
-
-void main() {
-  float texelFloatA = getTexelValue(textureA, vTexCoord, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-
-  if (aIsNodata || texelFloatA < filterLowA || texelFloatA > filterHighA) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA;
-    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
-  }
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+
+uniform sampler2D textureA;
+
+uniform float nodataValue;
+uniform bool littleEndian;
+
+uniform float filterLowA;
+uniform float filterHighA;
+uniform float multiplierA;
+
+varying vec2 vTexCoord;
+
+void main() {
+  float texelFloatA = getTexelValue(textureA, vTexCoord, littleEndian);
+
+  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+
+  if (aIsNodata || texelFloatA < filterLowA || texelFloatA > filterHighA) {
+    gl_FragColor = floatToRgba(nodataValue, littleEndian);
+  } else {
+    float texelFloatFinal = texelFloatA * multiplierA;
+    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
+  }
+}
 `

package/src/gl-operations/shaders/fragment/multiAnalyze2Calc.js

@@ -1,46 +1,46 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-
-uniform sampler2D textureA;
-uniform sampler2D textureB;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-
-uniform float filterLowA;
-uniform float filterHighA;
-uniform float filterLowB;
-uniform float filterHighB;
-uniform float multiplierA;
-uniform float multiplierB;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-
-void main() {
-  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-
-  if (aIsNodata || bIsNodata ||
-      texelFloatA < filterLowA || texelFloatA > filterHighA ||
-      texelFloatB < filterLowB || texelFloatB > filterHighB
-      ) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB;
-    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
-  }
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+
+uniform sampler2D textureA;
+uniform sampler2D textureB;
+
+uniform float nodataValue;
+uniform bool littleEndian;
+
+uniform float filterLowA;
+uniform float filterHighA;
+uniform float filterLowB;
+uniform float filterHighB;
+uniform float multiplierA;
+uniform float multiplierB;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+
+void main() {
+  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
+  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
+
+  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
+
+  if (aIsNodata || bIsNodata ||
+      texelFloatA < filterLowA || texelFloatA > filterHighA ||
+      texelFloatB < filterLowB || texelFloatB > filterHighB
+      ) {
+    gl_FragColor = floatToRgba(nodataValue, littleEndian);
+  } else {
+    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB;
+    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
+  }
+}
 `

package/src/gl-operations/shaders/fragment/multiAnalyze3Calc.js

@@ -1,54 +1,54 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-
-uniform sampler2D textureA;
-uniform sampler2D textureB;
-uniform sampler2D textureC;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-
-uniform float filterLowA;
-uniform float filterHighA;
-uniform float filterLowB;
-uniform float filterHighB;
-uniform float filterLowC;
-uniform float filterHighC;
-uniform float multiplierA;
-uniform float multiplierB;
-uniform float multiplierC;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-
-void main() {
-  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-  float texelFloatC = getTexelValue(textureC, vTexCoordC, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
-
-  if (aIsNodata || bIsNodata || cIsNodata ||
-      texelFloatA < filterLowA || texelFloatA > filterHighA ||
-      texelFloatB < filterLowB || texelFloatB > filterHighB ||
-      texelFloatC < filterLowC || texelFloatC > filterHighC
-      ) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC;
-    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
-  }
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+
+uniform sampler2D textureA;
+uniform sampler2D textureB;
+uniform sampler2D textureC;
+
+uniform float nodataValue;
+uniform bool littleEndian;
+
+uniform float filterLowA;
+uniform float filterHighA;
+uniform float filterLowB;
+uniform float filterHighB;
+uniform float filterLowC;
+uniform float filterHighC;
+uniform float multiplierA;
+uniform float multiplierB;
+uniform float multiplierC;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+
+void main() {
+  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
+  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
+  float texelFloatC = getTexelValue(textureC, vTexCoordC, littleEndian);
+
+  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
+  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
+
+  if (aIsNodata || bIsNodata || cIsNodata ||
+      texelFloatA < filterLowA || texelFloatA > filterHighA ||
+      texelFloatB < filterLowB || texelFloatB > filterHighB ||
+      texelFloatC < filterLowC || texelFloatC > filterHighC
+      ) {
+    gl_FragColor = floatToRgba(nodataValue, littleEndian);
+  } else {
+    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC;
+    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
+  }
+}
 `

package/src/gl-operations/shaders/fragment/multiAnalyze4Calc.js

@@ -1,62 +1,62 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
-#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
-#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
-
-uniform sampler2D textureA;
-uniform sampler2D textureB;
-uniform sampler2D textureC;
-uniform sampler2D textureD;
-
-uniform float nodataValue;
-uniform bool littleEndian;
-
-uniform float filterLowA;
-uniform float filterHighA;
-uniform float filterLowB;
-uniform float filterHighB;
-uniform float filterLowC;
-uniform float filterHighC;
-uniform float filterLowD;
-uniform float filterHighD;
-uniform float multiplierA;
-uniform float multiplierB;
-uniform float multiplierC;
-uniform float multiplierD;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-varying vec2 vTexCoordD;
-
-void main() {
-  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
-  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
-  float texelFloatC = getTexelValue(textureC, vTexCoordC, littleEndian);
-  float texelFloatD = getTexelValue(textureD, vTexCoordD, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
-  bool dIsNodata = isCloseEnough(texelFloatD, nodataValue);
-
-  if (aIsNodata || bIsNodata || cIsNodata || dIsNodata ||
-      texelFloatA < filterLowA || texelFloatA > filterHighA ||
-      texelFloatB < filterLowB || texelFloatB > filterHighB ||
-      texelFloatC < filterLowC || texelFloatC > filterHighC ||
-      texelFloatD < filterLowD || texelFloatD > filterHighD
-      ) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC + texelFloatD * multiplierD;
-    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
-  }
-}
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#pragma glslify: getTexelValue = require(../util/getTexelValue.glsl)
+#pragma glslify: floatToRgba = require(glsl-float-to-rgba)
+#pragma glslify: isCloseEnough = require(../util/isCloseEnough.glsl)
+
+uniform sampler2D textureA;
+uniform sampler2D textureB;
+uniform sampler2D textureC;
+uniform sampler2D textureD;
+
+uniform float nodataValue;
+uniform bool littleEndian;
+
+uniform float filterLowA;
+uniform float filterHighA;
+uniform float filterLowB;
+uniform float filterHighB;
+uniform float filterLowC;
+uniform float filterHighC;
+uniform float filterLowD;
+uniform float filterHighD;
+uniform float multiplierA;
+uniform float multiplierB;
+uniform float multiplierC;
+uniform float multiplierD;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+varying vec2 vTexCoordD;
+
+void main() {
+  float texelFloatA = getTexelValue(textureA, vTexCoordA, littleEndian);
+  float texelFloatB = getTexelValue(textureB, vTexCoordB, littleEndian);
+  float texelFloatC = getTexelValue(textureC, vTexCoordC, littleEndian);
+  float texelFloatD = getTexelValue(textureD, vTexCoordD, littleEndian);
+
+  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
+  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
+  bool dIsNodata = isCloseEnough(texelFloatD, nodataValue);
+
+  if (aIsNodata || bIsNodata || cIsNodata || dIsNodata ||
+      texelFloatA < filterLowA || texelFloatA > filterHighA ||
+      texelFloatB < filterLowB || texelFloatB > filterHighB ||
+      texelFloatC < filterLowC || texelFloatC > filterHighC ||
+      texelFloatD < filterLowD || texelFloatD > filterHighD
+      ) {
+    gl_FragColor = floatToRgba(nodataValue, littleEndian);
+  } else {
+    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC + texelFloatD * multiplierD;
+    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
+  }
+}
 `