@gisatcz/deckgl-geolib 1.12.0-dev.0 → 1.12.0-dev.11

package/src/cogtiles/cogtiles.ts

@@ -1,316 +0,0 @@
-/* eslint 'max-len': [1, { code: 100, comments: 999, ignoreStrings: true, ignoreUrls: true }] */
-// COG loading
-import { Tiff, TiffImage } from '@cogeotiff/core';
-import { SourceHttp } from '@chunkd/source-http';
-
-// 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.ts';
-
-export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
-
-const EARTH_CIRCUMFERENCE = 2 * Math.PI * 6378137;
-const EARTH_HALF_CIRCUMFERENCE = EARTH_CIRCUMFERENCE / 2;
-
-const CogTilesGeoImageOptionsDefaults = {
-  blurredTexture: true,
-};
-
-class CogTiles {
-  cog: Tiff;
-
-  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 = { ...CogTilesGeoImageOptionsDefaults, ...options };
-  }
-
-  async initializeCog(url: string) {
-    // Set native fetch instead node-fetch to SourceHttp
-    SourceHttp.fetch = async (input, init) => {
-      const res = await fetch(input, init);
-      return res;
-    };
-
-    const source = new SourceHttp(url);
-    this.cog = await Tiff.create(source);
-
-    this.cog.images.forEach((image:TiffImage) => {
-      image.loadGeoTiffTags();
-    });
-
-    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: Tiff) {
-    return cog.images[cog.images.length - 1].tileSize.width;
-  }
-
-  getZoomRange(cog: Tiff) {
-    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: Tiff) {
-    const { bbox } = cog.images[cog.images.length - 1];
-
-    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: Tiff) {
-    const { origin } = cog.images[cog.images.length - 1];
-    return this.getLatLon(origin);
-  }
-
-  getImageTileIndex(img: TiffImage) {
-    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, bounds:Bounds, meshMaxError: 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)
-
-      // const { meshMaxError, bounds, elevationDecoder } = this.options;
-
-      decompressed = await this.geo.getMap({
-        rasters: [decompressedFormatted],
-        width: this.tileSize,
-        height: this.tileSize,
-        bounds,
-      }, this.options, meshMaxError);
-
-      // 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;
-  }
-}
-
-export default CogTiles;

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');
-```