added parse

Author: DanielJDufour

src/index.js

@@ -1,16 +1,20 @@
-import bandArithmetic from './band-arithmetic';
-import cache from './cache';
-import get from './get';
-import histogram from './histogram';
-import identify from './identify';
-import load from './load';
-import max from './max';
-import mean from './mean';
-import median from './median';
-import min from './min';
-import mode from './mode';
-import rasterCalculator from './raster-calculator';
-import sum from './sum';
+/**
+ * @prettier
+ */
+import bandArithmetic from "./band-arithmetic";
+import cache from "./cache";
+import get from "./get";
+import histogram from "./histogram";
+import identify from "./identify";
+import load from "./load";
+import max from "./max";
+import mean from "./mean";
+import median from "./median";
+import min from "./min";
+import mode from "./mode";
+import parse from "./parse";
+import rasterCalculator from "./raster-calculator";
+import sum from "./sum";
 
 const geoblaze = {
   cache,
@@ -24,40 +28,26 @@ const geoblaze = {
   median,
   min,
   mode,
+  parse,
   rasterCalculator,
-  sum,
+  sum
 };
 
 export default geoblaze;
 
-export {
-  cache,
-  bandArithmetic,
-  get,
-  histogram,
-  identify,
-  load,
-  max,
-  mean,
-  median,
-  min,
-  mode,
-  rasterCalculator,
-  sum
-};
-
+export { cache, bandArithmetic, get, histogram, identify, load, max, mean, median, min, mode, parse, rasterCalculator, sum };
 
 /* set window.geoblaze in the browser */
-if (typeof window !== 'undefined') {
-  window['geoblaze'] = geoblaze;
+if (typeof window !== "undefined") {
+  window["geoblaze"] = geoblaze;
 }
 
 /* set self.geoblaze in a web worker */
-if (typeof self !== 'undefined') {
-  self['geoblaze'] = geoblaze;
+if (typeof self !== "undefined") {
+  self["geoblaze"] = geoblaze;
 }
 
 /* set global.geoblaze in node */
-if (typeof global !== 'undefined') {
-  global['geoblaze'] = geoblaze;
+if (typeof global !== "undefined") {
+  global["geoblaze"] = geoblaze;
 }

src/parse/index.js

@@ -0,0 +1,17 @@
+/**
+ * @prettier
+ */
+import parse from "./parse.module";
+
+/**
+ * The parse function takes a url to a geotiff or geotiff file as an input
+ * and returns a promise. The promise resolves as a georaster, which
+ * can be used as input in other geoblaze methods, such as identify, sum,
+ * or histogram.
+ * @name parse
+ * @param {Object|string} urlOrFile - a string representation of a url or a geotiff file
+ * @example
+ * const georaster = await geoblaze.parse(urlOrFile);
+ * const sums = sum(georaster, geometry);
+ */
+export default parse;

src/parse/parse.module.js

@@ -0,0 +1,32 @@
+/**
+ * @prettier
+ */
+import parseGeoRaster from "georaster";
+import nodeUrl from "url";
+import { ERROR_PARSING_GEOTIFF } from "../error-constants";
+import cache from "../cache";
+import utils from "../utils";
+
+const inBrowser = typeof window === "object";
+
+const URL = inBrowser ? window.URL : nodeUrl.parse;
+
+async function parseGeorasterWithErrorHandling(it, { logErrors }) {
+  try {
+    return await parseGeoRaster(it);
+  } catch (error) {
+    if (logErrors) console.error(error);
+    throw new Error(ERROR_PARSING_GEOTIFF);
+  }
+}
+
+export default async function parse(it, { logErrors = true } = { logErrors: true }) {
+  if (["Blob", "File"].includes(utils.getConstructorName(it))) it = URL.createObjectURL(it);
+
+  if (typeof it === "string") {
+    if (!cache[it]) cache[it] = parseGeorasterWithErrorHandling(it, { logErrors });
+    return await cache[it];
+  } else {
+    return await parseGeorasterWithErrorHandling(it);
+  }
+}

src/parse/parse.test.js

@@ -0,0 +1,86 @@
+/**
+ * @prettier
+ */
+import test from "flug";
+import fetch from "cross-fetch";
+import parse from "./index";
+import { serve } from "srvd";
+
+import {
+  // ERROR_BAD_URL
+  ERROR_PARSING_GEOTIFF
+} from "../error-constants";
+
+const path = "http://localhost:3000/data/test.tiff";
+const incorrectPath = "http://localhost:3000/data/this-is-not-a-real-dataset.tiff";
+const incorrectPath2 = "this-is-a-fake-path";
+//const incorrectPath3 = 'http://localhost:3000/data/random-file';
+
+const properties = [
+  "projection",
+  "xmin"
+  // 'values'
+];
+
+if (require.main === module) serve({ debug: true, port: 3000, wait: 15 });
+
+test("Loaded tiff export from geonode", async ({ eq }) => {
+  const url = "https://s3.amazonaws.com/georaster/geonode_atlanteil.tif";
+  const georaster = await parse(url, { logErrors: false });
+  properties.forEach(property => {
+    eq(property in georaster, true);
+  });
+});
+
+test("Loaded tiff file", async ({ eq }) => {
+  const georaster = await parse(path, { logErrors: false });
+  properties.forEach(property => {
+    eq(property in georaster, true);
+  });
+});
+
+test("Error from invalid URL", async ({ eq }) => {
+  let message;
+  try {
+    await parse(incorrectPath, { logErrors: false });
+  } catch (error) {
+    ({ message } = error);
+  }
+  eq(message, ERROR_PARSING_GEOTIFF);
+});
+
+test("Load: Error from another invalid URL tiff file", async ({ eq }) => {
+  let message;
+  try {
+    await parse(incorrectPath2, { logErrors: false });
+  } catch (error) {
+    ({ message } = error);
+  }
+  eq(message, ERROR_PARSING_GEOTIFF);
+});
+
+/*
+// commenting out this test because failing because Unhandled Promise Rejection
+// in georaster
+describe('Error from an invalid file', function () {
+  this.timeout(10);
+  it('Loaded tiff file', () => {
+    try {
+      return parse(incorrectPath3).then(null, error => {
+        expect(error.message).to.equal(ERROR_PARSING_GEOTIFF);
+      });
+    } catch(error) {
+      expect(error.message).to.equal(ERROR_PARSING_GEOTIFF);
+    }
+  });
+});
+*/
+
+// test('Loaded from tiff file', async ({ eq }) => {
+//   const blob = await fetch(path);
+//   const tiff = await parse(blob);
+//   let image = tiff.getImage();
+//   properties.forEach(property => {
+//     eq(property in image);
+//   })
+// });