@mapcatch/util 2.0.4 → 2.0.5-a

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

@@ -1,70 +1,70 @@
-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 sampler2D textureE;
-
-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 filterLowE;
-uniform float filterHighE;
-uniform float multiplierA;
-uniform float multiplierB;
-uniform float multiplierC;
-uniform float multiplierD;
-uniform float multiplierE;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-varying vec2 vTexCoordD;
-varying vec2 vTexCoordE;
-
-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);
-  float texelFloatE = getTexelValue(textureE, vTexCoordE, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
-  bool dIsNodata = isCloseEnough(texelFloatD, nodataValue);
-  bool eIsNodata = isCloseEnough(texelFloatE, nodataValue);
-
-  if (aIsNodata || bIsNodata || cIsNodata || dIsNodata || eIsNodata ||
-      texelFloatA < filterLowA || texelFloatA > filterHighA ||
-      texelFloatB < filterLowB || texelFloatB > filterHighB ||
-      texelFloatC < filterLowC || texelFloatC > filterHighC ||
-      texelFloatD < filterLowD || texelFloatD > filterHighD ||
-      texelFloatE < filterLowE || texelFloatE > filterHighE
-      ) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC + texelFloatD * multiplierD + texelFloatE * multiplierE;
-    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 sampler2D textureE;
+
+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 filterLowE;
+uniform float filterHighE;
+uniform float multiplierA;
+uniform float multiplierB;
+uniform float multiplierC;
+uniform float multiplierD;
+uniform float multiplierE;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+varying vec2 vTexCoordD;
+varying vec2 vTexCoordE;
+
+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);
+  float texelFloatE = getTexelValue(textureE, vTexCoordE, littleEndian);
+
+  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
+  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
+  bool dIsNodata = isCloseEnough(texelFloatD, nodataValue);
+  bool eIsNodata = isCloseEnough(texelFloatE, nodataValue);
+
+  if (aIsNodata || bIsNodata || cIsNodata || dIsNodata || eIsNodata ||
+      texelFloatA < filterLowA || texelFloatA > filterHighA ||
+      texelFloatB < filterLowB || texelFloatB > filterHighB ||
+      texelFloatC < filterLowC || texelFloatC > filterHighC ||
+      texelFloatD < filterLowD || texelFloatD > filterHighD ||
+      texelFloatE < filterLowE || texelFloatE > filterHighE
+      ) {
+    gl_FragColor = floatToRgba(nodataValue, littleEndian);
+  } else {
+    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC + texelFloatD * multiplierD + texelFloatE * multiplierE;
+    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
+  }
+}
 `

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

@@ -1,78 +1,78 @@
-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 sampler2D textureE;
-uniform sampler2D textureF;
-
-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 filterLowE;
-uniform float filterHighE;
-uniform float filterLowF;
-uniform float filterHighF;
-uniform float multiplierA;
-uniform float multiplierB;
-uniform float multiplierC;
-uniform float multiplierD;
-uniform float multiplierE;
-uniform float multiplierF;
-
-varying vec2 vTexCoordA;
-varying vec2 vTexCoordB;
-varying vec2 vTexCoordC;
-varying vec2 vTexCoordD;
-varying vec2 vTexCoordE;
-varying vec2 vTexCoordF;
-
-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);
-  float texelFloatE = getTexelValue(textureE, vTexCoordE, littleEndian);
-  float texelFloatF = getTexelValue(textureF, vTexCoordF, littleEndian);
-
-  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
-  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
-  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
-  bool dIsNodata = isCloseEnough(texelFloatD, nodataValue);
-  bool eIsNodata = isCloseEnough(texelFloatE, nodataValue);
-  bool fIsNodata = isCloseEnough(texelFloatF, nodataValue);
-
-  if (aIsNodata || bIsNodata || cIsNodata || dIsNodata || eIsNodata || fIsNodata ||
-      texelFloatA < filterLowA || texelFloatA > filterHighA ||
-      texelFloatB < filterLowB || texelFloatB > filterHighB ||
-      texelFloatC < filterLowC || texelFloatC > filterHighC ||
-      texelFloatD < filterLowD || texelFloatD > filterHighD ||
-      texelFloatE < filterLowE || texelFloatE > filterHighE ||
-      texelFloatF < filterLowF || texelFloatF > filterHighF
-      ) {
-    gl_FragColor = floatToRgba(nodataValue, littleEndian);
-  } else {
-    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC + texelFloatD * multiplierD + texelFloatE * multiplierE + texelFloatF * multiplierF;
-    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 sampler2D textureE;
+uniform sampler2D textureF;
+
+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 filterLowE;
+uniform float filterHighE;
+uniform float filterLowF;
+uniform float filterHighF;
+uniform float multiplierA;
+uniform float multiplierB;
+uniform float multiplierC;
+uniform float multiplierD;
+uniform float multiplierE;
+uniform float multiplierF;
+
+varying vec2 vTexCoordA;
+varying vec2 vTexCoordB;
+varying vec2 vTexCoordC;
+varying vec2 vTexCoordD;
+varying vec2 vTexCoordE;
+varying vec2 vTexCoordF;
+
+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);
+  float texelFloatE = getTexelValue(textureE, vTexCoordE, littleEndian);
+  float texelFloatF = getTexelValue(textureF, vTexCoordF, littleEndian);
+
+  bool aIsNodata = isCloseEnough(texelFloatA, nodataValue);
+  bool bIsNodata = isCloseEnough(texelFloatB, nodataValue);
+  bool cIsNodata = isCloseEnough(texelFloatC, nodataValue);
+  bool dIsNodata = isCloseEnough(texelFloatD, nodataValue);
+  bool eIsNodata = isCloseEnough(texelFloatE, nodataValue);
+  bool fIsNodata = isCloseEnough(texelFloatF, nodataValue);
+
+  if (aIsNodata || bIsNodata || cIsNodata || dIsNodata || eIsNodata || fIsNodata ||
+      texelFloatA < filterLowA || texelFloatA > filterHighA ||
+      texelFloatB < filterLowB || texelFloatB > filterHighB ||
+      texelFloatC < filterLowC || texelFloatC > filterHighC ||
+      texelFloatD < filterLowD || texelFloatD > filterHighD ||
+      texelFloatE < filterLowE || texelFloatE > filterHighE ||
+      texelFloatF < filterLowF || texelFloatF > filterHighF
+      ) {
+    gl_FragColor = floatToRgba(nodataValue, littleEndian);
+  } else {
+    float texelFloatFinal = texelFloatA * multiplierA + texelFloatB * multiplierB + texelFloatC * multiplierC + texelFloatD * multiplierD + texelFloatE * multiplierE + texelFloatF * multiplierF;
+    gl_FragColor = floatToRgba(texelFloatFinal, littleEndian);
+  }
+}
 `

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

@@ -1,93 +1,93 @@
-import glsl from 'glslify'
-
-export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-
-#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 texture;
-uniform bool littleEndian;
-uniform bool enableSimpleHillshade;
-
-uniform float textureSize;
-uniform float tileSize;
-uniform vec4 textureBounds;
-varying vec2 vTexCoord;
-
-uniform float offset;
-uniform float slopescale;
-uniform float slopeFactor;
-uniform float deg2rad;
-uniform float azimuth;
-uniform float altitude;
-
-uniform vec4 aboveColor;
-uniform vec4 belowColor;
-
-float getRelativeHeight(vec2 pos, float v, vec4 textureBounds) {
-  float pixelFloatValue = getTexelValue(texture, pos, littleEndian);
-  float test = step(0.0, pixelFloatValue);
-  float testReturn = ((test * pixelFloatValue) + ((1.0 - test) * v)) * (slopescale*slopeFactor);
-  return testReturn;
-}
-
-float hillshade(vec2 pos, float v, float offset, vec4 textureBounds) {
-  float cv = v * (slopescale * slopeFactor);
-  vec4 nv = vec4(
-  getRelativeHeight(vec2(pos.x + offset, pos.y), v, textureBounds),
-  getRelativeHeight(vec2(pos.x - offset, pos.y), v, textureBounds),
-  getRelativeHeight(vec2(pos.x, pos.y + offset), v, textureBounds),
-  getRelativeHeight(vec2(pos.x, pos.y - offset), v, textureBounds)
-  );
-
-  vec2 grad = vec2(
-    (nv[0] - cv) / 2.0 + (cv - nv[1]) / 2.0,
-    (nv[2] - cv) / 2.0 + (cv - nv[3]) / 2.0
-  );
-
-  float slope = max(3.141593 / 2.0 - atan(sqrt(dot(grad, grad))), 0.0);
-  float aspect = atan(-grad.y, grad.x);
-
-  float hs = sin(altitude * deg2rad) * sin(slope) +
-    cos(altitude * deg2rad) * cos(slope) *
-    cos((azimuth * deg2rad) - aspect);
-
-  return clamp(hs, 0.0, 1.0);
-}
-
-void main() {
-  float texelFloat = getTexelValue(texture, vTexCoord, littleEndian);
-
-  if (isCloseEnough(texelFloat, nodataValue)) {
-    discard;
-  }
-
-  vec4 clr = computeColor(
-    texelFloat,
-    scaleColormap,
-    sentinelColormap,
-    scaleLength,
-    sentinelLength,
-    littleEndian,
-    aboveColor,
-    belowColor
-  );
-
-  if (enableSimpleHillshade) {
-    float hs = hillshade(vTexCoord, texelFloat, offset, textureBounds);
-    clr.rgb = clr.rgb * hs;
-  }
-
-  gl_FragColor = clr;
-}`
+import glsl from 'glslify'
+
+export default glsl`#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+#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 texture;
+uniform bool littleEndian;
+uniform bool enableSimpleHillshade;
+
+uniform float textureSize;
+uniform float tileSize;
+uniform vec4 textureBounds;
+varying vec2 vTexCoord;
+
+uniform float offset;
+uniform float slopescale;
+uniform float slopeFactor;
+uniform float deg2rad;
+uniform float azimuth;
+uniform float altitude;
+
+uniform vec4 aboveColor;
+uniform vec4 belowColor;
+
+float getRelativeHeight(vec2 pos, float v, vec4 textureBounds) {
+  float pixelFloatValue = getTexelValue(texture, pos, littleEndian);
+  float test = step(0.0, pixelFloatValue);
+  float testReturn = ((test * pixelFloatValue) + ((1.0 - test) * v)) * (slopescale*slopeFactor);
+  return testReturn;
+}
+
+float hillshade(vec2 pos, float v, float offset, vec4 textureBounds) {
+  float cv = v * (slopescale * slopeFactor);
+  vec4 nv = vec4(
+  getRelativeHeight(vec2(pos.x + offset, pos.y), v, textureBounds),
+  getRelativeHeight(vec2(pos.x - offset, pos.y), v, textureBounds),
+  getRelativeHeight(vec2(pos.x, pos.y + offset), v, textureBounds),
+  getRelativeHeight(vec2(pos.x, pos.y - offset), v, textureBounds)
+  );
+
+  vec2 grad = vec2(
+    (nv[0] - cv) / 2.0 + (cv - nv[1]) / 2.0,
+    (nv[2] - cv) / 2.0 + (cv - nv[3]) / 2.0
+  );
+
+  float slope = max(3.141593 / 2.0 - atan(sqrt(dot(grad, grad))), 0.0);
+  float aspect = atan(-grad.y, grad.x);
+
+  float hs = sin(altitude * deg2rad) * sin(slope) +
+    cos(altitude * deg2rad) * cos(slope) *
+    cos((azimuth * deg2rad) - aspect);
+
+  return clamp(hs, 0.0, 1.0);
+}
+
+void main() {
+  float texelFloat = getTexelValue(texture, vTexCoord, littleEndian);
+
+  if (isCloseEnough(texelFloat, nodataValue)) {
+    discard;
+  }
+
+  vec4 clr = computeColor(
+    texelFloat,
+    scaleColormap,
+    sentinelColormap,
+    scaleLength,
+    sentinelLength,
+    littleEndian,
+    aboveColor,
+    belowColor
+  );
+
+  if (enableSimpleHillshade) {
+    float hs = hillshade(vTexCoord, texelFloat, offset, textureBounds);
+    clr.rgb = clr.rgb * hs;
+  }
+
+  gl_FragColor = clr;
+}`

package/src/gl-operations/shaders/transform.js

@@ -1,22 +1,22 @@
-var fs = require('fs')
-
-function transform (file) {
-  let extension = file.split('.').pop()
-  let content = fs.readFileSync(file, 'utf-8')
-  content = `import glsl from 'glslify'\n\nexport default glsl\`${content}\``
-  fs.writeFileSync(file.replace(`.${extension}`, '.js'), content)
-}
-
-function readDir (dir) {
-  let list = fs.readdirSync(dir)
-  list.forEach(item => {
-    let stats = fs.statSync(`${dir}/${item}`)
-    if (stats.isFile() && (item.endsWith('.vs') || item.endsWith('.fs'))) {
-      transform(`${dir}/${item}`)
-    } else if (stats.isDirectory()) {
-      readDir(`${dir}/${item}`)
-    }
-  })
-}
-
+var fs = require('fs')
+
+function transform (file) {
+  let extension = file.split('.').pop()
+  let content = fs.readFileSync(file, 'utf-8')
+  content = `import glsl from 'glslify'\n\nexport default glsl\`${content}\``
+  fs.writeFileSync(file.replace(`.${extension}`, '.js'), content)
+}
+
+function readDir (dir) {
+  let list = fs.readdirSync(dir)
+  list.forEach(item => {
+    let stats = fs.statSync(`${dir}/${item}`)
+    if (stats.isFile() && (item.endsWith('.vs') || item.endsWith('.fs'))) {
+      transform(`${dir}/${item}`)
+    } else if (stats.isDirectory()) {
+      readDir(`${dir}/${item}`)
+    }
+  })
+}
+
 readDir('./')