@gisatcz/deckgl-geolib 0.0.3 → 1.2.0

package/src/geoimage/README.md

@@ -0,0 +1,110 @@
+# GEOIMAGE
+#### A Javascript library for generating bitmaps 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.
+- The **elevation data** is encoded into the bitmap as [Mapbox Terrain-RGB](https://docs.mapbox.com/data/tilesets/guides/access-elevation-data/#decode-data).
+
+#### 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 data in specific opacity **(if useDataOpacity is false)** **(default 150)**
+- `useHeatMap : boolean` - generate data as a color heatmap **(default true)**
+ `useChannel : number | null` - specify a single channel to use **(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 such as `'red'`, `[255,0,0]`, `'#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`
+- `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.
+- `unidentifiedColor: chroma.Color` - set color for not identified values **if useColorsBasedOnValues 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])**
+
+## 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(120);
+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(120);
+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');
+```

package/src/geoimage/geoimage.ts

@@ -0,0 +1,390 @@
+/* eslint 'max-len': [1, { code: 105, comments: 999, ignoreStrings: true, ignoreUrls: true }] */
+
+// import { ExtentsLeftBottomRightTop } from '@deck.gl/core/utils/positions';
+import { fromArrayBuffer, GeoTIFFImage, TypedArray } from 'geotiff';
+import chroma from 'chroma-js';
+
+export type GeoImageOptions = {
+    type: 'image' | 'terrain',
+    format?: 'uint8' | 'uint16' | 'uint32' |'int8' | 'int16' | 'int32' | 'float32' | 'float64'
+    useHeatMap?: boolean,
+    useColorsBasedOnValues? : boolean,
+    useAutoRange?: boolean,
+    useDataForOpacity?: boolean,
+    useChannel?: number | null,
+    useSingleColor?: boolean,
+    clipLow?: number | null,
+    clipHigh?: number | null,
+    multiplier?: number,
+    color?: Array<number> | chroma.Color,
+    colorScale?: Array<string> | Array<chroma.Color>,
+    colorScaleValueRange?: number[],
+    colorsBasedOnValues? : [number|undefined, chroma.Color][],
+    alpha?: number,
+    noDataValue?: number
+    numOfChannels?: number,
+    nullColor?: Array<number> | chroma.Color
+    unidentifiedColor?: Array<number> | chroma.Color,
+    clippedColor?: Array<number> | chroma.Color
+}
+
+const DefaultGeoImageOptions: GeoImageOptions = {
+  type: 'image',
+  format: 'uint8',
+  useHeatMap: true,
+  useColorsBasedOnValues: false,
+  useAutoRange: false,
+  useDataForOpacity: false,
+  useSingleColor: false,
+  clipLow: null,
+  clipHigh: null,
+  multiplier: 1.0,
+  color: [255, 0, 255, 255],
+  colorScale: chroma.brewer.YlOrRd,
+  colorScaleValueRange: [0, 255],
+  colorsBasedOnValues: null,
+  alpha: 255,
+  useChannel: null,
+  noDataValue: undefined,
+  numOfChannels: undefined,
+  nullColor: [0, 0, 0, 0],
+  unidentifiedColor: [0, 0, 0, 0],
+  clippedColor: [0, 0, 0, 0],
+};
+
+export default class GeoImage {
+  data: GeoTIFFImage | undefined;
+
+  scale = (
+    num: number,
+    inMin: number,
+    inMax: number,
+    outMin: number,
+    outMax: number,
+  ) => ((num - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;
+
+  async setUrl(url: string) {
+    const response = await fetch(url);
+    const arrayBuffer = await response.arrayBuffer();
+    const tiff = await fromArrayBuffer(arrayBuffer);
+
+    const data = await tiff.getImage(0);
+
+    this.data = data;
+  }
+
+  async getMap(
+    input: string | {
+        width: number,
+        height: number,
+        rasters: any[]
+        },
+    options: GeoImageOptions,
+  ) {
+    const mergedOptions = { ...DefaultGeoImageOptions, ...options };
+
+    switch (mergedOptions.type) {
+      case 'image':
+        return this.getBitmap(input, mergedOptions);
+      case 'terrain':
+        return this.getHeightmap(input, mergedOptions);
+      default:
+        return null;
+    }
+  }
+
+  // GetHeightmap uses only "useChannel" and "multiplier" options
+  async getHeightmap(
+    input: string | {
+        width: number,
+        height: number,
+        rasters: any[] },
+    options: GeoImageOptions,
+  ) {
+    let rasters = [];
+    let width: number;
+    let height: number;
+
+    if (typeof (input) === 'string') {
+      await this.setUrl(input);
+
+      rasters = (await this.data!.readRasters()) as TypedArray[];
+      width = this.data!.getWidth();
+      height = this.data!.getHeight();
+    } else {
+      rasters = input.rasters;
+      width = input.width;
+      height = input.height;
+    }
+
+    let channel = rasters[0];
+
+    if (options.useChannel != null) {
+      if (rasters[options.useChannel]) {
+        channel = rasters[options.useChannel];
+      }
+    }
+
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const c = canvas.getContext('2d');
+    const imageData = c!.createImageData(width, height);
+
+    const channelCount = channel.length / (width * height);
+    const s = width * height * 4;
+
+    let pixel = 0;
+    if (options.useChannel != null) {
+      pixel = options.useChannel;
+    }
+
+    // console.time("heightmap generated in");
+    for (let i = 0; i < s; i += 4) {
+      channel[pixel] *= options.multiplier!;
+      const multiplied = 100000 + channel[pixel] * 10;
+
+      imageData.data[i] = Math.trunc(multiplied * 0.00001525878);
+      imageData.data[i + 1] = Math.trunc(multiplied * 0.00390625) - imageData.data[i] * 256;
+      imageData.data[i + 2] = Math.trunc(multiplied) - imageData.data[i] * 65536
+      - imageData.data[i + 1] * 256;
+      imageData.data[i + 3] = 255;
+
+      pixel += channelCount;
+    }
+
+    // console.timeEnd("heightmap generated in");
+
+    c!.putImageData(imageData, 0, 0);
+    const imageUrl = canvas.toDataURL('image/png');
+    // console.log('Heightmap generated.');
+    return imageUrl;
+  }
+
+  async getBitmap(
+    input: string | {
+        width: number,
+        height: number,
+        rasters: any[] },
+    options: GeoImageOptions,
+  ) {
+    // console.time('bitmap-generated-in');
+    // const optionsLocal = { ...options };
+    const optionsLocal = { ...options };
+
+    let rasters = [];
+    let channels: number;
+    let width: number;
+    let height: number;
+
+    if (typeof (input) === 'string') {
+      await this.setUrl(input);
+      rasters = (await this.data!.readRasters()) as TypedArray[];
+      channels = rasters.length;
+      width = this.data!.getWidth();
+      height = this.data!.getHeight();
+    } else {
+      rasters = input.rasters;
+      channels = rasters.length;
+      width = input.width;
+      height = input.height;
+    }
+    // TO DO if alpha is set in options, then apply to entire image
+
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const c = canvas.getContext('2d');
+    const imageData: ImageData = c!.createImageData(width, height);
+
+    let r; let g; let b; let
+      a;
+    const size = width * height * 4;
+
+    if (!options.noDataValue) {
+      console.log('Missing noData value. Raster might be displayed incorrectly.');
+    }
+    optionsLocal.unidentifiedColor = this.getColorFromChromaType(optionsLocal.unidentifiedColor);
+    optionsLocal.nullColor = this.getColorFromChromaType(optionsLocal.nullColor);
+    optionsLocal.clippedColor = this.getColorFromChromaType(optionsLocal.clippedColor);
+    optionsLocal.color = this.getColorFromChromaType(optionsLocal.color);
+
+    // console.log(rasters[0])
+    /* console.log("raster 0 length: " + rasters[0].length)
+    console.log("image width: " + width)
+    console.log("channels: " + channels)
+    console.log("format: " + rasters[0].length / (width * height))
+    */
+
+    if (optionsLocal.useChannel == null) {
+      if (channels === 1) {
+        if (rasters[0].length / (width * height) === 1) {
+          const channel = rasters[0];
+          // AUTO RANGE
+          if (optionsLocal.useAutoRange) {
+            optionsLocal.colorScaleValueRange = this.getMinMax(channel, optionsLocal);
+            // console.log('data min: ' + optionsLocal.rangeMin + ', max: ' + optionsLocal.rangeMax);
+          }
+          // SINGLE CHANNEL
+          const colorData = this.getColorValue(channel, optionsLocal, size);
+          colorData.forEach((value, index) => {
+            imageData.data[index] = value;
+          });
+        }
+        if (rasters[0].length / (width * height) === 3) {
+          // console.log("geoImage: " + "RGB 1 array of length: " + rasters[0].length);
+          let pixel = 0;
+          for (let i = 0; i < size; i += 4) {
+            imageData.data[i] = rasters[0][pixel += 1];
+            imageData.data[i + 1] = rasters[0][pixel += 1];
+            imageData.data[i + 2] = rasters[0][pixel += 1];
+            imageData.data[i + 3] = optionsLocal.alpha!;
+          }
+        }
+        if (rasters[0].length / (width * height) === 4) {
+          // console.log("geoImage: " + "RGBA 1 array");
+          rasters[0].forEach((value, index) => {
+            imageData.data[index] = value;
+          });
+        }
+      }
+      if (channels === 3) {
+        // RGB
+        let pixel = 0;
+        for (let i = 0; i < size; i += 4) {
+          r = rasters[0][pixel];
+          g = rasters[1][pixel];
+          b = rasters[2][pixel];
+          a = optionsLocal.alpha!;
+
+          imageData.data[i] = r;
+          imageData.data[i + 1] = g;
+          imageData.data[i + 2] = b;
+          imageData.data[i + 3] = a;
+
+          pixel += 1;
+        }
+      }
+      if (channels === 4) {
+        // RGBA
+        let pixel = 0;
+        for (let i = 0; i < size; i += 4) {
+          r = rasters[0][pixel];
+          g = rasters[1][pixel];
+          b = rasters[2][pixel];
+          a = optionsLocal.alpha!;
+
+          imageData.data[i] = r;
+          imageData.data[i + 1] = g;
+          imageData.data[i + 2] = b;
+          imageData.data[i + 3] = a;
+
+          pixel += 1;
+        }
+      }
+    } else if (optionsLocal.useChannel <= optionsLocal.numOfChannels) {
+      let channel = rasters[0];
+      if (rasters[optionsLocal.useChannel]) {
+        channel = rasters[optionsLocal.useChannel];
+      }
+      // AUTO RANGE
+      if (optionsLocal.useAutoRange) {
+        optionsLocal.colorScaleValueRange = this.getMinMax(channel, optionsLocal);
+        // console.log('data min: ' + optionsLocal.rangeMin + ', max: ' + optionsLocal.rangeMax);
+      }
+      const numOfChannels = channel.length / (width * height);
+      const colorData = this.getColorValue(channel, optionsLocal, size, numOfChannels);
+      colorData.forEach((value, index) => {
+        imageData.data[index] = value;
+      });
+    } else {
+      // if user defined channel does not exist --> return greyscale image
+      console.log('Defined channel does not exist, displaying only grey values');
+      const defaultColorData = this.getDefaultColor(size, optionsLocal.nullColor);
+      defaultColorData.forEach((value, index) => {
+        imageData.data[index] = value;
+      });
+    }
+    // console.timeEnd('bitmap-generated-in');
+
+        c!.putImageData(imageData, 0, 0);
+        const imageUrl = canvas.toDataURL('image/png');
+        // console.log('Bitmap generated.');
+        return imageUrl;
+  }
+
+  getMinMax(array, options) {
+    let maxValue = options.maxValue ? options.maxValue : Number.MIN_VALUE;
+    let minValue = options.minValue ? options.minValue : Number.MAX_VALUE;
+    for (let idx = 0; idx < array.length; idx += 1) {
+      if (!options.noDataValue || array[idx] !== options.noDataValue) {
+        if (array[idx] > maxValue) maxValue = array[idx];
+        if (array[idx] < minValue) minValue = array[idx];
+      }
+    }
+    return [minValue, maxValue];
+  }
+
+  getColorValue(dataArray:[], options:GeoImageOptions, arrayLength:number, numOfChannels = 1) {
+    const colorScale = chroma.scale(options.colorScale).domain(options.colorScaleValueRange);
+    let pixel:number = options.useChannel === null ? 0 : options.useChannel;
+    const colorsArray = new Array(arrayLength);
+
+    // for useColorsBasedOnValues
+    const dataValues = options.colorsBasedOnValues ? options.colorsBasedOnValues.map(([first]) => first) : undefined;
+    const colorValues = options.colorsBasedOnValues ? options.colorsBasedOnValues.map(([, second]) => [...chroma(second).rgb(), 255]) : undefined;
+
+    for (let i = 0; i < arrayLength; i += 4) {
+      let pixelColor = options.nullColor;
+      if (!options.noDataValue || dataArray[pixel] !== options.noDataValue) {
+        if (
+          (options.clipLow != null && dataArray[pixel] <= options.clipLow)
+                || (options.clipHigh != null && dataArray[pixel] >= options.clipHigh)
+        ) {
+          pixelColor = options.clippedColor;
+        } else {
+          if (options.useHeatMap) {
+            // FIXME
+            // eslint-disable-next-line
+            pixelColor = [...colorScale(dataArray[pixel]).rgb(), 255];
+          }
+          if (options.useColorsBasedOnValues) {
+            const index = dataValues.indexOf(dataArray[pixel]);
+            if (index > -1) {
+              pixelColor = colorValues[index];
+            } else pixelColor = options.unidentifiedColor;
+          }
+          if (options.useSingleColor) {
+            // FIXME - Is this compatible with chroma.color?
+            pixelColor = options.color;
+          }
+          if (options.useDataForOpacity) {
+            // eslint-disable-next-line max-len
+            pixelColor[3] = this.scale(dataArray[pixel], options.colorScaleValueRange[0]!, options.colorScaleValueRange.slice(-1)[0]!, 0, 255);
+          }
+        }
+      }
+      // FIXME
+      // eslint-disable-next-line
+      [colorsArray[i], colorsArray[i + 1], colorsArray[i + 2], colorsArray[i + 3]] = pixelColor;
+
+      pixel += numOfChannels;
+    }
+    return colorsArray;
+  }
+
+  getDefaultColor(size, nullColor) {
+    const colorsArray = new Array(size);
+    for (let i = 0; i < size; i += 4) {
+      [colorsArray[i], colorsArray[i + 1], colorsArray[i + 2], colorsArray[i + 3]] = nullColor;
+    }
+    return colorsArray;
+  }
+
+  getColorFromChromaType(colorDefinition) {
+    if (!Array.isArray(colorDefinition) || colorDefinition.length !== 4) {
+      return [...chroma(colorDefinition).rgb(), 255];
+    }
+    return colorDefinition;
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+import CogBitmapLayer from './cogbitmaplayer/CogBitmapLayer';
+import CogTerrainLayer from './cogterrainlayer/CogTerrainLayer';
+import cogtiles from './cogtiles/cogtiles';
+import GeoImage from './geoimage/geoimage';
+
+export default {
+  CogBitmapLayer,
+  CogTerrainLayer,
+  cogtiles,
+  GeoImage,
+};

package/src/utilities/tileurls.ts

@@ -0,0 +1,21 @@
+function isTileServiceUrl(url:string) {
+  if (url.includes('{x}') && url.includes('{y}') && url.includes('{z}')) {
+    return true;
+  }
+  return false;
+}
+
+function isCogUrl(url:string) {
+  if (url.includes('.tif') || url.includes('.tiff') || url.includes('.TIF') || url.includes('.TIFF')) {
+    return true;
+  }
+  return false;
+}
+
+function getTileUrl(service:string, x:number, y:number, z:number) {
+  const url = service.replace('{x}', String(x)).replace('{y}', String(y)).replace('{z}', String(z));
+
+  return url;
+}
+
+export { isTileServiceUrl, isCogUrl, getTileUrl };

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../tsconfig.json",
+}

package/README.md

@@ -1 +0,0 @@
-# geoimage

package/dist/cjs/classes/geoImage/GeoImage.d.ts

@@ -1,38 +0,0 @@
-import { GeoTIFFImage } from 'geotiff';
-import { IGeoImage } from './interface';
-declare class GeoImage implements IGeoImage {
-    url: string;
-    origin: number[];
-    boundingBox: number[];
-    data: GeoTIFFImage | undefined;
-    useHeatMap: boolean;
-    useAutoRange: boolean;
-    useClip: boolean;
-    useDataForOpacity: boolean;
-    rangeMin: number;
-    rangeMax: number;
-    clipLow: number;
-    clipHigh: number;
-    multiplier: number;
-    color: number[];
-    alpha: number;
-    imageWidth: number;
-    imageHeight: number;
-    options: {};
-    useChannel: number;
-    scale: (num: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
-    getOrigin: () => number[];
-    getBoundingBox: () => number[];
-    setUrl(url: string): Promise<void>;
-    getHeightMap(input: any): Promise<string>;
-    getBitmap(input: any): Promise<string>;
-    setDataOpacity(toggle?: boolean): void;
-    setHeatMap(heat?: boolean): void;
-    setAutoRange(auto?: boolean): void;
-    setDataClip(low?: number, high?: number): void;
-    setDataRange(min?: number, max?: number): void;
-    setMultiplier(n?: number): void;
-    setColor(r?: number, g?: number, b?: number): void;
-    setOpacity(alpha?: number): void;
-}
-export default GeoImage;

package/dist/cjs/classes/geoImage/index.d.ts

@@ -1 +0,0 @@
-export { default } from './GeoImage';

package/dist/cjs/classes/geoImage/interface.d.ts

@@ -1,32 +0,0 @@
-import { GeoTIFFImage } from 'geotiff';
-export interface IGeoImage {
-    url: string;
-    origin: number[];
-    boundingBox: number[];
-    data: GeoTIFFImage | undefined;
-    useHeatMap: boolean;
-    useAutoRange: boolean;
-    useClip: boolean;
-    useDataForOpacity: boolean;
-    rangeMin: number;
-    rangeMax: number;
-    clipLow: number;
-    clipHigh: number;
-    color: number[];
-    alpha: number;
-    imageWidth: number;
-    imageHeight: number;
-    setUrl(url: string): Promise<void>;
-    scale: (num: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
-    getOrigin: () => number[];
-    getBoundingBox: () => number[];
-    getBitmap(input: any): Promise<string>;
-    getHeightMap(input: any): Promise<string>;
-    setDataOpacity(toggle?: boolean): void;
-    setHeatMap(heat?: boolean): void;
-    setAutoRange(auto?: boolean): void;
-    setDataClip(low?: number, high?: number): void;
-    setDataRange(min?: number, max?: number): void;
-    setColor(r?: number, g?: number, b?: number): void;
-    setOpacity(alpha?: number): void;
-}

package/dist/cjs/classes/index.d.ts

@@ -1 +0,0 @@
-export { default as GeoImage } from './geoImage';

package/dist/cjs/hooks/index.d.ts

@@ -1 +0,0 @@
-export { default as useGeoData } from './useGeoData';

package/dist/cjs/hooks/useGeoData/index.d.ts

@@ -1 +0,0 @@
-export { default } from './useGeoData';

package/dist/cjs/hooks/useGeoData/useGeoData.d.ts

@@ -1,9 +0,0 @@
-interface IGeo {
-    image: string;
-    bbox: Array<Number>;
-    viewState: any;
-    heightMap: string;
-    loaded: boolean;
-}
-declare const useGeoData: (url: string, useHeightMap: boolean | undefined, opacity: number) => IGeo;
-export default useGeoData;

package/dist/cjs/index.d.ts

@@ -1,2 +0,0 @@
-export * from './classes';
-export * from './hooks';

package/dist/cjs/types/classes/geoImage/GeoImage.d.ts

@@ -1,38 +0,0 @@
-import { GeoTIFFImage } from 'geotiff';
-import { IGeoImage } from './interface';
-declare class GeoImage implements IGeoImage {
-    url: string;
-    origin: number[];
-    boundingBox: number[];
-    data: GeoTIFFImage | undefined;
-    useHeatMap: boolean;
-    useAutoRange: boolean;
-    useClip: boolean;
-    useDataForOpacity: boolean;
-    rangeMin: number;
-    rangeMax: number;
-    clipLow: number;
-    clipHigh: number;
-    multiplier: number;
-    color: number[];
-    alpha: number;
-    imageWidth: number;
-    imageHeight: number;
-    options: {};
-    useChannel: number;
-    scale: (num: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
-    getOrigin: () => number[];
-    getBoundingBox: () => number[];
-    setUrl(url: string): Promise<void>;
-    getHeightMap(input: any): Promise<string>;
-    getBitmap(input: any): Promise<string>;
-    setDataOpacity(toggle?: boolean): void;
-    setHeatMap(heat?: boolean): void;
-    setAutoRange(auto?: boolean): void;
-    setDataClip(low?: number, high?: number): void;
-    setDataRange(min?: number, max?: number): void;
-    setMultiplier(n?: number): void;
-    setColor(r?: number, g?: number, b?: number): void;
-    setOpacity(alpha?: number): void;
-}
-export default GeoImage;

package/dist/cjs/types/classes/geoImage/index.d.ts

@@ -1 +0,0 @@
-export { default } from './GeoImage';