@gisatcz/deckgl-geolib 0.0.3 → 1.2.0

package/src/cogtiles/README.md

@@ -0,0 +1,72 @@
+# COGTILES
+
+
+
+#### A Javascript library for easier tile functionality with COG files
+
+
+
+## Features
+
+Class allows using CogTiff files with Deck.gl TileLayer.
+
+Provides extra functionality for CogTiff files
+
+
+
+
+
+
+
+
+
+## Methods
+
+
+
+`async initializeCog(url : string)`- returns a cog from a given URL and initializes object variables
+
+
+
+`async getTile(x: number, y: number, z: number)` - returns a promise, when resolved returns a tile. `x, y, z ` are coordinates in tile grid
+
+
+
+`getTileSize(CogTiff)` - returns `number` containing the width of a single tile
+
+
+
+`getZoomRange(cog:CogTiff)` - returns` [minZoom, maxZoom]` 
+
+
+
+`getBoundsAsLatLon(cog:CogTiff)` - returns image bounds as `[left, bottom, right, top]`
+
+
+
+`getOriginAsLatLon(cog:CogTiff)`- returns origin of COG as `[x, y]`
+
+
+
+`getImageTileIndex(img:CogTiffImage)` - returns index of an image from COG in tile system as`[x, y, z]`
+
+
+
+`getResolutionFromZoomLevel`- returns `number` in meters per pixel
+
+
+
+`getZoomLevelFromResolution(tileSize: number, resolution: number)` returns `number` zoom level calculated from `resolution` (the size of one pixel in meters) and `tileSize` (width of a tile)
+
+
+
+`getLatLon` - returns `[latitude, longitude]` from offset in meters
+
+
+
+
+
+
+
+
+

package/src/cogtiles/cogtiles.ts

@@ -0,0 +1,355 @@
+/* eslint 'max-len': [1, { code: 100, comments: 999, ignoreStrings: true, ignoreUrls: true }] */
+// COG loading
+import { CogTiff, CogTiffImage } from '@cogeotiff/core';
+import { SourceUrl } from '@chunkd/source-url';
+
+// Image compression support
+import { inflate } from 'pako';
+import jpeg from 'jpeg-js';
+import { worldToLngLat } from '@math.gl/web-mercator';
+import LZWDecoder from './lzw';
+
+// Bitmap styling
+import GeoImage, { GeoImageOptions } from '../geoimage/geoimage'; // TODO: remove absolute path
+
+const EARTH_CIRCUMFERENCE = 40075000.0;
+const EARTH_HALF_CIRCUMFERENCE = 20037500.0;
+
+class CogTiles {
+  cog: CogTiff;
+
+  zoomRange = [0, 0];
+
+  tileSize: number;
+
+  lowestOriginTileOffset = [0, 0];
+
+  lowestOriginTileSize = 0;
+
+  loaded: boolean = false;
+
+  geo: GeoImage = new GeoImage();
+
+  lzw: LZWDecoder = new LZWDecoder();
+
+  options: GeoImageOptions;
+
+  constructor(options: GeoImageOptions) {
+    this.options = options;
+
+    // this.testCog()
+  }
+
+  async initializeCog(url: string) {
+    // Set native fetch instead node-fetch to SourceUrl
+    SourceUrl.fetch = async (input, init) => {
+      const res = await fetch(input, init);
+      return res;
+    };
+
+    const sourceUrl = new SourceUrl(url);
+    this.cog = await CogTiff.create(sourceUrl);
+
+    this.cog.images.forEach((image:CogTiffImage) => {
+      image.loadGeoTiffTags();
+    });
+
+    /*
+        console.log("---- START OF COG INFO DUMP ----")
+        this.cog.images[0].tags.forEach((tag) => {
+            //console.log(tag.value.name)
+            console.log(tag.name + ":")
+            console.log(tag.value)
+        })
+        console.log("---- END OF COG INFO DUMP ----")
+        */
+    // console.log(this.cog)
+
+    this.tileSize = this.getTileSize(this.cog);
+
+    this.lowestOriginTileOffset = this.getImageTileIndex(
+      this.cog.images[this.cog.images.length - 1],
+    );
+
+    this.zoomRange = this.getZoomRange(this.cog);
+
+    return this.cog;
+  }
+
+  getTileSize(cog: CogTiff) {
+    return cog.images[cog.images.length - 1].tileSize.width;
+  }
+
+  getZoomRange(cog: CogTiff) {
+    const img = cog.images[cog.images.length - 1];
+
+    const minZoom = this.getZoomLevelFromResolution(
+      cog.images[cog.images.length - 1].tileSize.width,
+      img.resolution[0],
+    );
+    const maxZoom = minZoom + (cog.images.length - 1);
+
+    return [minZoom, maxZoom];
+  }
+
+  getBoundsAsLatLon(cog: CogTiff) {
+    const { bbox } = cog.images[cog.images.length - 1];
+
+    // console.log(bbox)
+
+    const minX = Math.min(bbox[0], bbox[2]);
+    const maxX = Math.max(bbox[0], bbox[2]);
+    const minY = Math.min(bbox[1], bbox[3]);
+    const maxY = Math.max(bbox[1], bbox[3]);
+
+    const minXYDeg = this.getLatLon([minX, minY]);
+    const maxXYDeg = this.getLatLon([maxX, maxY]);
+
+    return [minXYDeg[0], minXYDeg[1], maxXYDeg[0], maxXYDeg[1]] as [number, number, number, number];
+  }
+
+  getOriginAsLatLon(cog: CogTiff) {
+    const { origin } = cog.images[cog.images.length - 1];
+    return this.getLatLon(origin);
+  }
+
+  getImageTileIndex(img: CogTiffImage) {
+    const ax = EARTH_HALF_CIRCUMFERENCE + img.origin[0];
+    const ay = -(EARTH_HALF_CIRCUMFERENCE + (img.origin[1] - EARTH_CIRCUMFERENCE));
+    // let mpt = img.resolution[0] * img.tileSize.width;
+
+    const mpt = img.tileSize.width * this.getResolutionFromZoomLevel(
+      img.tileSize.width,
+      this.getZoomLevelFromResolution(
+        img.tileSize.width,
+        img.resolution[0],
+      ),
+    );
+
+    const ox = Math.round(ax / mpt);
+    const oy = Math.round(ay / mpt);
+
+    const oz = this.getZoomLevelFromResolution(img.tileSize.width, img.resolution[0]);
+
+    return [ox, oy, oz];
+  }
+
+  getResolutionFromZoomLevel(tileSize: number, z: number) {
+    return (EARTH_CIRCUMFERENCE / tileSize) / (2 ** z);
+  }
+
+  getZoomLevelFromResolution(tileSize: number, resolution: number) {
+    return Math.round(Math.log2(EARTH_CIRCUMFERENCE / (resolution * tileSize)));
+  }
+
+  getLatLon(input: number[]) {
+    const ax = EARTH_HALF_CIRCUMFERENCE + input[0];
+    const ay = -(EARTH_HALF_CIRCUMFERENCE + (input[1] - EARTH_CIRCUMFERENCE));
+
+    const cartesianPosition = [
+      ax * (512 / EARTH_CIRCUMFERENCE),
+      ay * (512 / EARTH_CIRCUMFERENCE),
+    ];
+    const cartographicPosition = worldToLngLat(cartesianPosition);
+    const cartographicPositionAdjusted = [cartographicPosition[0], -cartographicPosition[1]];
+
+    return cartographicPositionAdjusted;
+  }
+
+  async getTile(x: number, y: number, z: number) {
+    const wantedMpp = this.getResolutionFromZoomLevel(this.tileSize, z);
+    const img = this.cog.getImageByResolution(wantedMpp);
+    // await img.loadGeoTiffTags(1)
+    let offset: number[] = [0, 0];
+
+    if (z === this.zoomRange[0]) {
+      offset = this.lowestOriginTileOffset;
+    } else {
+      const power = 2 ** (z - this.zoomRange[0]);
+      offset[0] = Math.floor(this.lowestOriginTileOffset[0] * power);
+      offset[1] = Math.floor(this.lowestOriginTileOffset[1] * power);
+    }
+    const tilesX = img.tileCount.x;
+    const tilesY = img.tileCount.y;
+    // console.log("------OFFSET IS------  " + offset[0] + " ; " + offset[1])
+
+    const ox = offset[0];
+    const oy = offset[1];
+
+    // console.log("Asking for " + Math.floor(x - ox) + " : " + Math.floor(y - oy))
+
+    let decompressed: string;
+    let decoded: any;
+
+    this.options.numOfChannels = Number(img.tags.get(277).value);
+    this.options.noDataValue = this.getNoDataValue(img.tags);
+
+    if (!this.options.format) {
+      // More information about TIFF tags: https://www.awaresystems.be/imaging/tiff/tifftags.html
+      this.options.format = this.getFormat(
+img.tags.get(339).value as Array<number>,
+      img.tags.get(258).value as Array<number>,
+      );
+    }
+
+    let bitsPerSample = img.tags.get(258)!.value;
+    if (Array.isArray(bitsPerSample)) {
+      if (this.options.type === 'terrain') {
+        let c = 0;
+        bitsPerSample.forEach((sample) => {
+          c += sample;
+        });
+        bitsPerSample = c;
+      } else {
+        [bitsPerSample] = bitsPerSample;
+      }
+    }
+
+    // const samplesPerPixel = img.tags.get(277)!.value
+    // console.log("Samples per pixel:" + samplesPerPixel)
+    // console.log("Bits per sample: " + bitsPerSample)
+    // console.log("Single channel pixel format: " + bitsPerSample/)
+
+    if (x - ox >= 0 && y - oy >= 0 && x - ox < tilesX && y - oy < tilesY) {
+      // console.log("getting tile: " + [x - ox, y - oy]);
+      const tile = await img.getTile((x - ox), (y - oy));
+      // console.time("Request to data time: ")
+
+      switch (img.compression) {
+        case 'image/jpeg':
+          decoded = jpeg.decode(tile!.bytes, { useTArray: true });
+          break;
+        case 'application/deflate':
+          decoded = await inflate(tile!.bytes);
+          break;
+        case 'application/lzw':
+          decoded = this.lzw.decodeBlock(tile!.bytes.buffer);
+          break;
+        default:
+          console.warn(`Unexpected compression method: ${img.compression}`);
+      }
+
+      let decompressedFormatted;
+      // bitsPerSample = 8
+
+      switch (this.options.format) {
+        case 'uint8':
+          decompressedFormatted = new Uint8Array(decoded.buffer); break;
+        case 'uint16':
+          decompressedFormatted = new Uint16Array(decoded.buffer); break;
+        case 'uint32':
+          decompressedFormatted = new Uint32Array(decoded.buffer); break;
+        case 'int8':
+          decompressedFormatted = new Int8Array(decoded.buffer); break;
+        case 'int16':
+          decompressedFormatted = new Int16Array(decoded.buffer); break;
+        case 'int32':
+          decompressedFormatted = new Int32Array(decoded.buffer); break;
+        case 'float32':
+          decompressedFormatted = new Float32Array(decoded.buffer); break;
+        case 'float64':
+          decompressedFormatted = new Float64Array(decoded.buffer); break;
+        default: decompressedFormatted = null;
+      }
+
+      // console.log(decompressedFormatted)
+
+      decompressed = await this.geo.getMap({
+        rasters: [decompressedFormatted],
+        width: this.tileSize,
+        height: this.tileSize,
+      }, this.options);
+
+      // console.log(decompressed.length)
+
+      return decompressed;
+    }
+    return null;
+  }
+
+  getFormat(sampleFormat: number[]|number, bitsPerSample:number[]|number) {
+    // TO DO: what if there are different channels formats
+    let uniqueSampleFormat = sampleFormat;
+    let uniqueBitsPerSample = bitsPerSample;
+    if (Array.isArray(sampleFormat)) { [uniqueSampleFormat] = sampleFormat; }
+    if (Array.isArray(bitsPerSample)) { [uniqueBitsPerSample] = bitsPerSample; }
+
+    let dataType;
+    switch (uniqueSampleFormat) {
+      case 1: // Unsigned integer
+        switch (uniqueBitsPerSample) {
+          case 8: dataType = 'uint8'; break;
+          case 16: dataType = 'uint16'; break;
+          case 32: dataType = 'uint32'; break;
+          default: dataType = null;
+        }
+        break;
+      case 2: // Signed integer
+        switch (uniqueBitsPerSample) {
+          case 8: dataType = 'int8'; break;
+          case 16: dataType = 'int16'; break;
+          case 32: dataType = 'int32'; break;
+          default: dataType = null;
+        }
+        break;
+      case 3: // Floating point
+        switch (uniqueBitsPerSample) {
+          case 32: dataType = 'float32'; break;
+          case 64: dataType = 'float64'; break;
+          default: dataType = null;
+        }
+        break;
+      default:
+        throw new Error('Unknown data format.');
+    }
+    // console.log('Data type is: ', dataType)
+    return dataType;
+  }
+
+  getNoDataValue(tags) {
+    if (tags.has(42113)) {
+      const noDataValue = tags.get(42113).value;
+      if (typeof noDataValue === 'string' || noDataValue instanceof String) {
+        const parsedValue = noDataValue.replace(/[\0\s]/g, '');
+        return Number(parsedValue);
+      }
+      return Number.isNaN(Number(noDataValue)) ? undefined : Number(noDataValue);
+    }
+    return undefined;
+  }
+
+  async testCog() {
+    const url = 'https://gisat-gis.eu-central-1.linodeobjects.com/eman/versions/v2/Quadrants/Q3_Bolivia_ASTER_2002_RGB_COG_LZW.tif';
+    this.options = {
+      type: 'image', multiplier: 1.0, useChannel: 1, alpha: 180, clipLow: 1, clipHigh: Number.MAX_VALUE,
+    };
+
+    const c = await this.initializeCog(url);
+    const middleImage = c.images[Math.floor(c.images.length / 2)];
+
+    console.log(middleImage);
+
+    const imageTileIndex = this.getImageTileIndex(middleImage);
+
+    console.log(imageTileIndex);
+
+    const x = Math.floor(middleImage.tileCount.x / 2);
+    const y = Math.floor(middleImage.tileCount.y / 2);
+
+    console.log(c.getTile(x, y, Math.floor(c.images.length / 2)));
+
+    const tileGlobalX = x + imageTileIndex[0];
+    const tileGlobalY = y + imageTileIndex[1];
+    const tileGlobalZ = imageTileIndex[2];
+
+    const tile = await this.getTile(tileGlobalX, tileGlobalY, tileGlobalZ);
+
+    if (tile === false) {
+      console.log("couldn't retrieve tile");
+    } else {
+      console.log(tile);
+    }
+  }
+}
+
+export default CogTiles;

package/src/cogtiles/lzw.js

@@ -0,0 +1,256 @@
+/* eslint-disable no-mixed-operators */
+/* eslint-disable max-len */
+/* eslint-disable no-bitwise */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-plusplus */
+/* eslint-disable max-classes-per-file */
+/* eslint 'max-len': [1, { code: 100, comments: 999, ignoreStrings: true, ignoreUrls: true }] */
+
+// LITERALLY STOLEN CODE FROM GITHUB
+// NOT MY RESPONSIBILITY
+
+function decodeRowAcc(row, stride) {
+  let length = row.length - stride;
+  let offset = 0;
+  do {
+    for (let i = stride; i > 0; i--) {
+      row[offset + stride] += row[offset];
+      offset++;
+    }
+
+    length -= stride;
+  } while (length > 0);
+}
+
+function decodeRowFloatingPoint(row, stride, bytesPerSample) {
+  let index = 0;
+  let count = row.length;
+  const wc = count / bytesPerSample;
+
+  while (count > stride) {
+    for (let i = stride; i > 0; --i) {
+      row[index + stride] += row[index];
+      ++index;
+    }
+    count -= stride;
+  }
+
+  const copy = row.slice();
+  for (let i = 0; i < wc; ++i) {
+    for (let b = 0; b < bytesPerSample; ++b) {
+      row[(bytesPerSample * i) + b] = copy[((bytesPerSample - b - 1) * wc) + i];
+    }
+  }
+}
+
+function applyPredictor(
+  block,
+  predictor,
+  width,
+  height,
+  bitsPerSample,
+  planarConfiguration,
+) {
+  if (!predictor || predictor === 1) {
+    return block;
+  }
+
+  for (let i = 0; i < bitsPerSample.length; ++i) {
+    if (bitsPerSample[i] % 8 !== 0) {
+      throw new Error('When decoding with predictor, only multiple of 8 bits are supported.');
+    }
+    if (bitsPerSample[i] !== bitsPerSample[0]) {
+      throw new Error('When decoding with predictor, all samples must have the same size.');
+    }
+  }
+
+  const bytesPerSample = bitsPerSample[0] / 8;
+  const stride = planarConfiguration === 2 ? 1 : bitsPerSample.length;
+
+  for (let i = 0; i < height; ++i) {
+    // Last strip will be truncated if height % stripHeight != 0
+    if (i * stride * width * bytesPerSample >= block.byteLength) {
+      break;
+    }
+    let row;
+    if (predictor === 2) { // horizontal prediction
+      switch (bitsPerSample[0]) {
+        case 8:
+          row = new Uint8Array(block, i * stride * width * bytesPerSample, stride * width * bytesPerSample);
+          break;
+        case 16:
+          row = new Uint16Array(block, i * stride * width * bytesPerSample, stride * width * bytesPerSample / 2);
+          break;
+        case 32:
+          row = new Uint32Array(block, i * stride * width * bytesPerSample, stride * width * bytesPerSample / 4);
+          break;
+        default:
+          throw new Error(`Predictor 2 not allowed with ${bitsPerSample[0]} bits per sample.`);
+      }
+      decodeRowAcc(row, stride, bytesPerSample);
+    } else if (predictor === 3) { // horizontal floating point
+      row = new Uint8Array(block, i * stride * width * bytesPerSample, stride * width * bytesPerSample);
+      decodeRowFloatingPoint(row, stride, bytesPerSample);
+    }
+  }
+  return block;
+}
+
+class BaseDecoder {
+  async decode(fileDirectory, buffer) {
+    const decoded = await this.decodeBlock(buffer);
+    const predictor = fileDirectory.Predictor || 1;
+    if (predictor !== 1) {
+      const isTiled = !fileDirectory.StripOffsets;
+      const tileWidth = isTiled ? fileDirectory.TileWidth : fileDirectory.ImageWidth;
+      const tileHeight = isTiled
+        ? fileDirectory.TileLength
+        : (
+          fileDirectory.RowsPerStrip || fileDirectory.ImageLength
+        );
+      return applyPredictor(
+        decoded,
+        predictor,
+        tileWidth,
+        tileHeight,
+        fileDirectory.BitsPerSample,
+        fileDirectory.PlanarConfiguration,
+      );
+    }
+    return decoded;
+  }
+}
+
+const MIN_BITS = 9;
+const CLEAR_CODE = 256; // clear code
+const EOI_CODE = 257; // end of information
+const MAX_BYTELENGTH = 12;
+
+function getByte(array, position, length) {
+  const d = position % 8;
+  const a = Math.floor(position / 8);
+  const de = 8 - d;
+  const ef = (position + length) - ((a + 1) * 8);
+  let fg = (8 * (a + 2)) - (position + length);
+  const dg = ((a + 2) * 8) - position;
+  fg = Math.max(0, fg);
+  if (a >= array.length) {
+    console.warn('ran off the end of the buffer before finding EOI_CODE (end on input code)');
+    return EOI_CODE;
+  }
+  let chunk1 = array[a] & ((2 ** (8 - d)) - 1);
+  chunk1 <<= (length - de);
+  let chunks = chunk1;
+  if (a + 1 < array.length) {
+    let chunk2 = array[a + 1] >>> fg;
+    chunk2 <<= Math.max(0, (length - dg));
+    chunks += chunk2;
+  }
+  if (ef > 8 && a + 2 < array.length) {
+    const hi = ((a + 3) * 8) - (position + length);
+    const chunk3 = array[a + 2] >>> hi;
+    chunks += chunk3;
+  }
+  return chunks;
+}
+
+function appendReversed(dest, source) {
+  for (let i = source.length - 1; i >= 0; i--) {
+    dest.push(source[i]);
+  }
+  return dest;
+}
+
+function decompress(input) {
+  const dictionaryIndex = new Uint16Array(4093);
+  const dictionaryChar = new Uint8Array(4093);
+  for (let i = 0; i <= 257; i++) {
+    dictionaryIndex[i] = 4096;
+    dictionaryChar[i] = i;
+  }
+  let dictionaryLength = 258;
+  let byteLength = MIN_BITS;
+  let position = 0;
+
+  function initDictionary() {
+    dictionaryLength = 258;
+    byteLength = MIN_BITS;
+  }
+  function getNext(array) {
+    const byte = getByte(array, position, byteLength);
+    position += byteLength;
+    return byte;
+  }
+  function addToDictionary(i, c) {
+    dictionaryChar[dictionaryLength] = c;
+    dictionaryIndex[dictionaryLength] = i;
+    dictionaryLength++;
+    return dictionaryLength - 1;
+  }
+  function getDictionaryReversed(n) {
+    const rev = [];
+    for (let i = n; i !== 4096; i = dictionaryIndex[i]) {
+      rev.push(dictionaryChar[i]);
+    }
+    return rev;
+  }
+
+  const result = [];
+  initDictionary();
+  const array = new Uint8Array(input);
+  let code = getNext(array);
+  let oldCode;
+  while (code !== EOI_CODE) {
+    if (code === CLEAR_CODE) {
+      initDictionary();
+      code = getNext(array);
+      while (code === CLEAR_CODE) {
+        code = getNext(array);
+      }
+
+      if (code === EOI_CODE) {
+        break;
+      } else if (code > CLEAR_CODE) {
+        throw new Error(`corrupted code at scanline ${code}`);
+      } else {
+        const val = getDictionaryReversed(code);
+        appendReversed(result, val);
+        oldCode = code;
+      }
+    } else if (code < dictionaryLength) {
+      const val = getDictionaryReversed(code);
+      appendReversed(result, val);
+      addToDictionary(oldCode, val[val.length - 1]);
+      oldCode = code;
+    } else {
+      const oldVal = getDictionaryReversed(oldCode);
+      if (!oldVal) {
+        throw new Error(
+          `Bogus entry. Not in dictionary,
+                 ${oldCode} / ${dictionaryLength},
+                  position: ${position}`,
+        );
+      }
+      appendReversed(result, oldVal);
+      result.push(oldVal[oldVal.length - 1]);
+      addToDictionary(oldCode, oldVal[oldVal.length - 1]);
+      oldCode = code;
+    }
+
+    if (dictionaryLength + 1 >= (2 ** byteLength)) {
+      if (byteLength === MAX_BYTELENGTH) {
+        oldCode = undefined;
+      } else {
+        byteLength++;
+      }
+    }
+    code = getNext(array);
+  }
+  return new Uint8Array(result);
+}
+
+export default class LZWDecoder extends BaseDecoder {
+  decodeBlock(buffer) {
+    return decompress(buffer, false).buffer;
+  }
+}