@gisatcz/deckgl-geolib 1.12.0-dev.5 → 2.1.0-dev.0

package/src/cogtiles/lzw.js

@@ -1,256 +0,0 @@
-/* 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;
-  }
-}

package/src/geoimage/README.md

@@ -1,129 +0,0 @@
-# Geoimage
-##### A Javascript library for rendering bitmaps and terrain out of **geoTIFF** files.
-<img src = "/images/example0crop1.png" width = "100%">
-
-### Features
-##### Color texture generation
-- Create RGB pictures out of RGB geoTIFF data.
-- Generate pictures out of non-RGB geoTIFF data with different processing options.
-
-##### Terrain texture generation
-- Generate heightmaps out of single-channel geoTIFF elevation data.
-- Create tiled mesh layer which represents height values fron geoTIFF without any compression to height PNG. 
-- Created mesh is TIN generated by [martini algorithm](https://github.com/mapbox/martini).
-
-
-##### Data visualisation options
-- Color
-- Transparency
-- Heatmap (custom color scale example [here](../cogbitmaplayer/README.md#custom-heatmap-color-scale))
-- Data slice
-- Automatic data range
-- Manual data range
-- Assign color to specific data value (example [here](../cogbitmaplayer/README.md#assigning-color-to-specific-data-value))
-
-### Data processing options
-- `useAutoRange : boolean` - set automatic range of color gradient **(default false)**
-- `useDataForOpacity : boolean` - visualise data with opacity of each pixel according to its value **(default false)**
-- `alpha : number` - visualise entire image with specified opacity **(if useDataOpacity is false)**, values 0-100 **(default 100)**
-- `useHeatMap : boolean` - generate data as a color heatmap **(default true)**
-- `useChannel : number | null` - specify a single channel to use; first channel is equal to 1, etc... for RGB(A) imagery leave it to `null` **(default null)**
-- `multiplier : number  ` - multiplies each value **(default 1.00)**
-- `clipLow : number | null`- generate only data greater than this **(default null)**
-
-- `clipHigh : number | null`- generate only data less than this **(default null)**
-- `clippedColor: chroma.Color` - set color for clipped values when using `clipLow` or `clipHigh`, **(default [0, 0, 0, 0])**
-- `colorScale:chroma.Color[]` - array of colors, supports chroma.js color definition (more below)
-- `colorScaleValueRange: number[]` - set min and max range values or set any array of values to set exact colors to values, **if useAutoRange is false**, **(default [0,255])**
-- `useColorsBasedOnValues: boolean` - assign pixels colors based on defined data values **(default false)**
-- `colorsBasedOnValues : [number, chroma.Color][]` - array of value-color pairs, used **if useColorsBasedOnValues is true**, supports chroma.js color definition such as `'red'`, `[255,0,0]`, `'#FF0000'`, etc.
-- `useColorClasses: boolean` - determines whether pixel colors are assigned based on predefined data classes (intervals) **(default false)**
-- `colorClasses : [chroma.Color, [number, number], [boolean, boolean]?][]` - array of color-interval(-intervalBounds) triples, where the color is defined as chroma.js color; interval is defined as [min, max] array; and optional inteval bound as [boolean, boolean] array (default is [true, false] for all intervals except the last one which is [false, true]; used **if useColorClasses is true**, the values that don't belong to any interval are visualized as `unidentifiedColor`
-- `unidentifiedColor: chroma.Color` - set color for not identified values **if useColorsBasedOnValues or useColorClasses is true**, **(default [0, 0, 0, 0])**
-- `nullColor : chroma.Color` - set color for noData values **(default [0, 0, 0, 0])**
-- `useSingleColor : boolean` - display data values only with single color **(default false)**
-- `color : chroma.Color` - set color when **if useSingleColor is true**, **(default [255, 0, 255, 255])**
-- `blurredTexture : boolean` - define blurring behaviour for textures when zoomed in = magnification filter parameter (`gl.TEXTURE_MAG_FILTER`). Default is `true` for blurry textures (corresponds to `GL.LINEAR`), to not blur textures use `false` (corresponds to `GL.NEAREST`)
-
-#### Chroma.Color definition
-Type `chroma.Color` means any color definition that is supported by chroma.js such as `'red'`, `[255,0,0]`, `[255,0,0, 180]`, `'#FF0000'`, 
-etc. and [Color Brewer pallete names](https://www.datanovia.com/en/wp-content/uploads/dn-tutorials/ggplot2/figures/0101-rcolorbrewer-palette-rcolorbrewer-palettes-colorblind-friendly-1.png) 
-in this format: `chroma.brewer.Greens`
-
-#### Additional terrain processing options
-- `terrainMinValue: number` - noData value retrieved from input file's metadata is substitute by this value **(default 0)**
-- `terrainSkirtHeight: number` - defines height of individual tiles edges, so there are no white spaces between individual 3D tiles **(default 100)**
-
-[//]: # (- `terrainColor: chroma.Color` - color of terrain model **&#40;default [133, 133, 133, 255]&#41;**)
-
-- Setting **opacity for terrain layers**: Terrayin layer is ordinary Deck.gl layer instance, so opacity is common prop.
-
-### Return options
-**Method returns Image DataUrl**
-
-- `getMap(returnFormat : "image" | "terrain", input : string | { width : number, height : number, rasters : any[] }, options?: { opacity : number })`
-
-  If `returnFormat` = `"image"` - If the input has 3 or 4 color channels, return standard RGB or RGBA image. If the input has 1 channel, data gets processed according to data processing options.
-
-  If `returnFormat` = `"terrain"` - Ignores all options except `multiplier` and returns  [Mapbox Terrain-RGB](https://docs.mapbox.com/data/tilesets/guides/access-elevation-data/#decode-data)
-
-### Basic example
-##### Initialize the library
-```typescript
-import GeoImage from 'geoimage';
-
-const g = new GeoImage();
-```
-##### Get bitmap
-```typescript
-const bitmap = await g.getMap("image", 'image.tif');
-```
-```typescript
-const bitmap = await g.getMap("image", { width : 512, height : 512, rasters : [[...data]] });
-```
-
-
-
-##### Get heightmap
-
-```typescript
-const heightmap = await g.getMap("terrain", 'image.tif');
-```
-```typescript
-const bitmap = await g.getMap("terrain", { width : 512, height : 512, rasters : [[...data]] });
-```
-
-### Advanced example
-
-```typescript
-//Import the library and initiate GeoImage object:
-import GeoImage from 'geoimage';
-
-const g = new GeoImage();
-
-//Single-channel geotiff as a transparent heatmap with auto-rage:
-g.useAutoRange(true);
-g.useHeatMap(true);
-g.alpha(100);
-const firstImage = await g.getMap("image", 'image.tif');
-
-//Single-channel geotiff as a transparent heatmap with manual range in meters:
-g.useAutoRange(false);
-g.useDataRange(0,250); //Blue at 0m, red at 250m
-g.useHeatMap(true);
-g.alpha(80);
-const secondImage = await g.getBitmap("image", 'image.tif');
-
-//Single-channel geotiff with data as transparency:
-g.useAutoRange(true);
-g.useHeatMap(false);
-g.useDataForOpacity(true);
-const thirdImage = await g.getBitmap("image", 'image.tif');
-
-//Single-channel geotiff with data slice from 350m to 360m in custom color:
-g.clipLow(350); //generate only data between 350m and 360m
-g.clipHigh(360); 
-g.useHeatMap(false);
-g.color[0,255,100];
-const fourthImage = await g.getBitmap("image", 'image.tif');
-```