@jupytergis/base 0.1.5 → 0.1.7

package/lib/dialogs/symbology/components/color_ramp/CanvasSelectComponent.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface IColorMap {
+    name: string;
+    colors: string[];
+}
+interface ICanvasSelectComponentProps {
+    selectedRamp: string;
+    setSelected: (item: any) => void;
+}
+declare const CanvasSelectComponent: ({ selectedRamp, setSelected }: ICanvasSelectComponentProps) => React.JSX.Element;
+export default CanvasSelectComponent;

package/lib/dialogs/symbology/components/color_ramp/CanvasSelectComponent.js

@@ -0,0 +1,119 @@
+import { Button } from '@jupyterlab/ui-components';
+import colormap from 'colormap';
+import React, { useEffect, useRef, useState } from 'react';
+import ColorRampEntry from './ColorRampEntry';
+const CanvasSelectComponent = ({ selectedRamp, setSelected }) => {
+    const colorRampNames = [
+        'jet',
+        // 'hsv', 11 steps min
+        'hot',
+        'cool',
+        'spring',
+        'summer',
+        'autumn',
+        'winter',
+        'bone',
+        'copper',
+        'greys',
+        'YiGnBu',
+        'greens',
+        'YiOrRd',
+        'bluered',
+        'RdBu',
+        // 'picnic', 11 steps min
+        'rainbow',
+        'portland',
+        'blackbody',
+        'earth',
+        'electric',
+        'viridis',
+        'inferno',
+        'magma',
+        'plasma',
+        'warm',
+        // 'rainbow-soft', 11 steps min
+        'bathymetry',
+        'cdom',
+        'chlorophyll',
+        'density',
+        'freesurface-blue',
+        'freesurface-red',
+        'oxygen',
+        'par',
+        'phase',
+        'salinity',
+        'temperature',
+        'turbidity',
+        'velocity-blue',
+        'velocity-green'
+        // 'cubehelix' 16 steps min
+    ];
+    const containerRef = useRef(null);
+    const [isOpen, setIsOpen] = useState(false);
+    const [colorMaps, setColorMaps] = useState([]);
+    useEffect(() => {
+        const colorMapList = [];
+        colorRampNames.forEach(name => {
+            const colorRamp = colormap({
+                colormap: name,
+                nshades: 255,
+                format: 'rgbaString'
+            });
+            const colorMap = { name: name, colors: colorRamp };
+            colorMapList.push(colorMap);
+            setColorMaps(colorMapList);
+        });
+    }, []);
+    useEffect(() => {
+        if (colorMaps.length > 0) {
+            updateCanvas(selectedRamp);
+        }
+    }, [selectedRamp]);
+    const toggleDropdown = () => {
+        setIsOpen(!isOpen);
+    };
+    const selectItem = (item) => {
+        setSelected(item);
+        setIsOpen(false);
+        updateCanvas(item);
+    };
+    const handleOutsideClick = (event) => {
+        if (!containerRef.current) {
+            return;
+        }
+        if (!containerRef.current.contains(event.target)) {
+            setIsOpen(false);
+        }
+    };
+    const updateCanvas = (rampName) => {
+        // update canvas for displayed color ramp
+        const canvas = document.getElementById('cv');
+        if (!canvas) {
+            return;
+        }
+        canvas.style.visibility = 'hidden';
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            return;
+        }
+        const ramp = colorMaps.filter(c => c.name === rampName);
+        for (let i = 0; i <= 255; i++) {
+            ctx.beginPath();
+            const color = ramp[0].colors[i];
+            ctx.fillStyle = color;
+            ctx.fillRect(i * 2, 0, 2, 50);
+        }
+        canvas.style.visibility = 'initial';
+    };
+    useEffect(() => {
+        document.addEventListener('mousedown', handleOutsideClick);
+        return () => {
+            document.removeEventListener('mousedown', handleOutsideClick);
+        };
+    }, []);
+    return (React.createElement("div", { ref: containerRef, className: "jp-gis-canvas-button-wrapper" },
+        React.createElement(Button, { id: "jp-gis-canvas-button", onClick: toggleDropdown, className: "jp-Dialog-button jp-gis-canvas-button" },
+            React.createElement("canvas", { id: "cv", className: "jp-gis-color-canvas-display", height: "30" })),
+        React.createElement("div", { className: `jp-gis-color-ramp-dropdown ${isOpen ? 'jp-gis-open' : ''}` }, colorMaps.map((item, index) => (React.createElement(ColorRampEntry, { index: index, colorMap: item, onClick: selectItem }))))));
+};
+export default CanvasSelectComponent;

package/lib/dialogs/symbology/components/color_ramp/ColorRamp.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { IDict } from '@jupytergis/schema';
+interface IColorRampProps {
+    modeOptions: string[];
+    layerParams: IDict;
+    classifyFunc: (selectedMode: string, numberOfShades: string, selectedRamp: string, setIsLoading: (isLoading: boolean) => void) => void;
+    showModeRow: boolean;
+}
+export type ColorRampOptions = {
+    selectedRamp: string;
+    numberOfShades: string;
+    selectedMode: string;
+};
+declare const ColorRamp: ({ layerParams, modeOptions, classifyFunc, showModeRow }: IColorRampProps) => React.JSX.Element;
+export default ColorRamp;

package/lib/dialogs/symbology/components/color_ramp/ColorRamp.js

@@ -0,0 +1,33 @@
+import { Button } from '@jupyterlab/ui-components';
+import React, { useEffect, useState } from 'react';
+import CanvasSelectComponent from './CanvasSelectComponent';
+import { faSpinner } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import ModeSelectRow from './ModeSelectRow';
+const ColorRamp = ({ layerParams, modeOptions, classifyFunc, showModeRow }) => {
+    const [selectedRamp, setSelectedRamp] = useState('');
+    const [selectedMode, setSelectedMode] = useState('');
+    const [numberOfShades, setNumberOfShades] = useState('');
+    const [isLoading, setIsLoading] = useState(false);
+    useEffect(() => {
+        populateOptions();
+    }, []);
+    const populateOptions = async () => {
+        let nClasses, singleBandMode, colorRamp;
+        if (layerParams.symbologyState) {
+            nClasses = layerParams.symbologyState.nClasses;
+            singleBandMode = layerParams.symbologyState.mode;
+            colorRamp = layerParams.symbologyState.colorRamp;
+        }
+        setNumberOfShades(nClasses ? nClasses : '9');
+        setSelectedMode(singleBandMode ? singleBandMode : 'equal interval');
+        setSelectedRamp(colorRamp ? colorRamp : 'cool');
+    };
+    return (React.createElement("div", { className: "jp-gis-color-ramp-container" },
+        React.createElement("div", { className: "jp-gis-symbology-row" },
+            React.createElement("label", { htmlFor: "color-ramp-select" }, "Color Ramp:"),
+            React.createElement(CanvasSelectComponent, { selectedRamp: selectedRamp, setSelected: setSelectedRamp })),
+        showModeRow && (React.createElement(ModeSelectRow, { modeOptions: modeOptions, numberOfShades: numberOfShades, setNumberOfShades: setNumberOfShades, selectedMode: selectedMode, setSelectedMode: setSelectedMode })),
+        isLoading ? (React.createElement(FontAwesomeIcon, { icon: faSpinner, className: "jp-gis-loading-spinner" })) : (React.createElement(Button, { className: "jp-Dialog-button jp-mod-accept jp-mod-styled", onClick: () => classifyFunc(selectedMode, numberOfShades, selectedRamp, setIsLoading) }, "Classify"))));
+};
+export default ColorRamp;

package/lib/dialogs/symbology/components/color_ramp/ColorRampEntry.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { IColorMap } from './CanvasSelectComponent';
+interface IColorRampEntryProps {
+    index: number;
+    colorMap: IColorMap;
+    onClick: (item: any) => void;
+}
+declare const ColorRampEntry: ({ index, colorMap, onClick }: IColorRampEntryProps) => React.JSX.Element;
+export default ColorRampEntry;

package/lib/dialogs/symbology/components/color_ramp/ColorRampEntry.js

@@ -0,0 +1,24 @@
+import React, { useEffect } from 'react';
+const ColorRampEntry = ({ index, colorMap, onClick }) => {
+    const canvasHeight = 30;
+    useEffect(() => {
+        const canvas = document.getElementById(`cv-${index}`);
+        if (!canvas) {
+            return;
+        }
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            return;
+        }
+        for (let i = 0; i <= 255; i++) {
+            ctx.beginPath();
+            const color = colorMap.colors[i];
+            ctx.fillStyle = color;
+            ctx.fillRect(i * 2, 0, 2, canvasHeight);
+        }
+    }, []);
+    return (React.createElement("div", { key: colorMap.name, onClick: () => onClick(colorMap.name), className: "jp-gis-color-ramp-entry" },
+        React.createElement("span", { className: "jp-gis-color-label" }, colorMap.name),
+        React.createElement("canvas", { id: `cv-${index}`, height: canvasHeight, className: "jp-gis-color-canvas" })));
+};
+export default ColorRampEntry;

package/lib/dialogs/symbology/components/color_ramp/ModeSelectRow.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface IModeSelectRowProps {
+    numberOfShades: string;
+    setNumberOfShades: (value: string) => void;
+    selectedMode: string;
+    setSelectedMode: (value: string) => void;
+    modeOptions: string[];
+}
+declare const ModeSelectRow: ({ numberOfShades, setNumberOfShades, selectedMode, setSelectedMode, modeOptions }: IModeSelectRowProps) => React.JSX.Element;
+export default ModeSelectRow;

package/lib/dialogs/symbology/components/color_ramp/ModeSelectRow.js

@@ -0,0 +1,11 @@
+import React from 'react';
+const ModeSelectRow = ({ numberOfShades, setNumberOfShades, selectedMode, setSelectedMode, modeOptions }) => {
+    return (React.createElement("div", { className: "jp-gis-symbology-row" },
+        React.createElement("div", { className: "jp-gis-color-ramp-div" },
+            React.createElement("label", { htmlFor: "class-number-input" }, "Classes:"),
+            React.createElement("input", { className: "jp-mod-styled", name: "class-number-input", type: "number", value: selectedMode === 'continuous' ? 52 : numberOfShades, onChange: event => setNumberOfShades(event.target.value), disabled: selectedMode === 'continuous' })),
+        React.createElement("div", { className: "jp-gis-color-ramp-div" },
+            React.createElement("label", { htmlFor: "mode-select" }, "Mode:"),
+            React.createElement("select", { name: "mode-select", onChange: event => setSelectedMode(event.target.value) }, modeOptions.map(mode => (React.createElement("option", { className: "jp-mod-styled", value: mode, selected: selectedMode === mode }, mode)))))));
+};
+export default ModeSelectRow;

package/lib/dialogs/symbology/components/color_stops/StopContainer.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { IStopRow } from '../../symbologyDialog';
+interface IStopContainerProps {
+    selectedMethod: string;
+    stopRows: IStopRow[];
+    setStopRows: (stops: IStopRow[]) => void;
+}
+declare const StopContainer: ({ selectedMethod, stopRows, setStopRows }: IStopContainerProps) => React.JSX.Element;
+export default StopContainer;

package/lib/dialogs/symbology/components/color_stops/StopContainer.js

@@ -0,0 +1,28 @@
+import React from 'react';
+import { Button } from '@jupyterlab/ui-components';
+import StopRow from './StopRow';
+const StopContainer = ({ selectedMethod, stopRows, setStopRows }) => {
+    const addStopRow = () => {
+        setStopRows([
+            {
+                stop: 0,
+                output: [0, 0, 0, 1]
+            },
+            ...stopRows
+        ]);
+    };
+    const deleteStopRow = (index) => {
+        const newFilters = [...stopRows];
+        newFilters.splice(index, 1);
+        setStopRows(newFilters);
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "jp-gis-stop-container" },
+            React.createElement("div", { className: "jp-gis-stop-labels", style: { display: 'flex', gap: 6 } },
+                React.createElement("span", { style: { flex: '0 0 18%' } }, "Value"),
+                React.createElement("span", null, "Output Value")),
+            stopRows.map((stop, index) => (React.createElement(StopRow, { key: `${index}-${stop.output}`, index: index, value: stop.stop, outputValue: stop.output, stopRows: stopRows, setStopRows: setStopRows, deleteRow: () => deleteStopRow(index), useNumber: selectedMethod === 'radius' ? true : false })))),
+        React.createElement("div", { className: "jp-gis-symbology-button-container" },
+            React.createElement(Button, { className: "jp-Dialog-button jp-mod-accept jp-mod-styled", onClick: addStopRow }, "Add Stop"))));
+};
+export default StopContainer;

package/lib/dialogs/{components/symbology → symbology/components/color_stops}/StopRow.js

@@ -1,8 +1,15 @@
 import { faTrash } from '@fortawesome/free-solid-svg-icons';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { Button } from '@jupyterlab/ui-components';
-import React from 'react';
+import React, { useEffect, useRef } from 'react';
 const StopRow = ({ index, value, outputValue, stopRows, setStopRows, deleteRow, useNumber }) => {
+    const inputRef = useRef(null);
+    useEffect(() => {
+        var _a;
+        if (inputRef.current === document.activeElement) {
+            (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+    }, [stopRows]);
     const rgbArrToHex = (rgbArr) => {
         if (!Array.isArray(rgbArr)) {
             return;
@@ -56,7 +63,7 @@ const StopRow = ({ index, value, outputValue, stopRows, setStopRows, deleteRow,
     };
     return (React.createElement("div", { className: "jp-gis-color-row" },
         React.createElement("input", { id: `jp-gis-color-value-${index}`, type: "number", value: value, onChange: handleStopChange, onBlur: handleBlur, className: "jp-mod-styled jp-gis-color-row-value-input" }),
-        useNumber ? (React.createElement("input", { type: "number", value: outputValue, onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })) : (React.createElement("input", { id: `jp-gis-color-color-${index}`, value: rgbArrToHex(outputValue), type: "color", onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })),
+        useNumber ? (React.createElement("input", { type: "number", ref: inputRef, value: outputValue, onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })) : (React.createElement("input", { id: `jp-gis-color-color-${index}`, ref: inputRef, value: rgbArrToHex(outputValue), type: "color", onChange: handleOutputChange, className: "jp-mod-styled jp-gis-color-row-output-input" })),
         React.createElement(Button, { id: `jp-gis-remove-color-${index}`, className: "jp-Button jp-gis-filter-icon" },
             React.createElement(FontAwesomeIcon, { icon: faTrash, onClick: deleteRow }))));
 };

package/lib/dialogs/symbology/hooks/useGetProperties.d.ts

@@ -0,0 +1,12 @@
+import { IJupyterGISModel } from '@jupytergis/schema';
+interface IUseGetPropertiesProps {
+    layerId?: string;
+    model: IJupyterGISModel;
+}
+interface IUseGetPropertiesResult {
+    featureProps: Record<string, Set<any>>;
+    isLoading: boolean;
+    error?: Error;
+}
+export declare const useGetProperties: ({ layerId, model }: IUseGetPropertiesProps) => IUseGetPropertiesResult;
+export {};

package/lib/dialogs/symbology/hooks/useGetProperties.js

@@ -0,0 +1,47 @@
+// import { GeoJSONFeature } from 'geojson';
+import { useEffect, useState } from 'react';
+export const useGetProperties = ({ layerId, model }) => {
+    const [featureProps, setFeatureProps] = useState({});
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(undefined);
+    const getProperties = async () => {
+        var _a, _b;
+        if (!layerId) {
+            return;
+        }
+        try {
+            const layer = model.getLayer(layerId);
+            const source = model.getSource((_a = layer === null || layer === void 0 ? void 0 : layer.parameters) === null || _a === void 0 ? void 0 : _a.source);
+            if (!source) {
+                throw new Error('Source not found');
+            }
+            const data = await model.readGeoJSON((_b = source.parameters) === null || _b === void 0 ? void 0 : _b.path);
+            if (!data) {
+                throw new Error('Failed to read GeoJSON data');
+            }
+            const result = {};
+            data.features.forEach((feature) => {
+                if (feature.properties) {
+                    Object.entries(feature.properties).forEach(([key, value]) => {
+                        if (typeof value !== 'string') {
+                            if (!(key in result)) {
+                                result[key] = new Set();
+                            }
+                            result[key].add(value);
+                        }
+                    });
+                }
+            });
+            setFeatureProps(result);
+            setIsLoading(false);
+        }
+        catch (err) {
+            setError(err);
+            setIsLoading(false);
+        }
+    };
+    useEffect(() => {
+        getProperties();
+    }, [model, layerId]);
+    return { featureProps, isLoading, error };
+};

package/lib/dialogs/{symbologyDialog.js → symbology/symbologyDialog.js}

@@ -2,8 +2,8 @@ import { Dialog } from '@jupyterlab/apputils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import React, { useEffect, useState } from 'react';
-import BandRendering from './components/symbology/BandRendering';
-import VectorRendering from './components/symbology/VectorRendering';
+import TiffRendering from './tiff_layer/TiffRendering';
+import VectorRendering from './vector_layer/VectorRendering';
 const SymbologyDialog = ({ context, state, okSignalPromise, cancel }) => {
     const [selectedLayer, setSelectedLayer] = useState(null);
     const [componentToRender, setComponentToRender] = useState(null);
@@ -39,7 +39,7 @@ const SymbologyDialog = ({ context, state, okSignalPromise, cancel }) => {
                 LayerSymbology = (React.createElement(VectorRendering, { context: context, state: state, okSignalPromise: okSignalPromise, cancel: cancel, layerId: selectedLayer }));
                 break;
             case 'WebGlLayer':
-                LayerSymbology = (React.createElement(BandRendering, { context: context, state: state, okSignalPromise: okSignalPromise, cancel: cancel, layerId: selectedLayer }));
+                LayerSymbology = (React.createElement(TiffRendering, { context: context, state: state, okSignalPromise: okSignalPromise, cancel: cancel, layerId: selectedLayer }));
                 break;
             default:
                 LayerSymbology = React.createElement("div", null, "Layer Type Not Supported");

package/lib/dialogs/symbology/symbologyUtils.d.ts

@@ -0,0 +1,9 @@
+import { IJGISLayer } from '@jupytergis/schema';
+import { IStopRow } from './symbologyDialog';
+export declare namespace VectorUtils {
+    const buildColorInfo: (layer: IJGISLayer) => IStopRow[];
+    const buildRadiusInfo: (layer: IJGISLayer) => IStopRow[];
+}
+export declare namespace Utils {
+    const getValueColorPairs: (stops: number[], selectedRamp: string, nClasses: number) => IStopRow[];
+}

package/lib/dialogs/symbology/symbologyUtils.js

@@ -0,0 +1,94 @@
+import colormap from 'colormap';
+export var VectorUtils;
+(function (VectorUtils) {
+    VectorUtils.buildColorInfo = (layer) => {
+        var _a;
+        // This it to parse a color object on the layer
+        if (!((_a = layer.parameters) === null || _a === void 0 ? void 0 : _a.color)) {
+            return [];
+        }
+        const color = layer.parameters.color;
+        // If color is a string we don't need to parse
+        if (typeof color === 'string') {
+            return [];
+        }
+        const prefix = layer.parameters.type === 'circle' ? 'circle-' : '';
+        if (!color[`${prefix}fill-color`]) {
+            return [];
+        }
+        const valueColorPairs = [];
+        // So if it's not a string then it's an array and we parse
+        // Color[0] is the operator used for the color expression
+        switch (color[`${prefix}fill-color`][0]) {
+            case 'interpolate':
+                // First element is interpolate for linear selection
+                // Second element is type of interpolation (ie linear)
+                // Third is input value that stop values are compared with
+                // Fourth and on is value:color pairs
+                for (let i = 3; i < color[`${prefix}fill-color`].length; i += 2) {
+                    const obj = {
+                        stop: color[`${prefix}fill-color`][i],
+                        output: color[`${prefix}fill-color`][i + 1]
+                    };
+                    valueColorPairs.push(obj);
+                }
+                break;
+            case 'case':
+                for (let i = 1; i < color[`${prefix}fill-color`].length - 1; i += 2) {
+                    const obj = {
+                        stop: color[`${prefix}fill-color`][i][2],
+                        output: color[`${prefix}fill-color`][i + 1]
+                    };
+                    valueColorPairs.push(obj);
+                }
+                break;
+        }
+        return valueColorPairs;
+    };
+    VectorUtils.buildRadiusInfo = (layer) => {
+        var _a;
+        if (!((_a = layer.parameters) === null || _a === void 0 ? void 0 : _a.color)) {
+            return [];
+        }
+        const color = layer.parameters.color;
+        // If color is a string we don't need to parse
+        if (typeof color === 'string') {
+            return [];
+        }
+        const stopOutputPairs = [];
+        for (let i = 3; i < color['circle-radius'].length; i += 2) {
+            const obj = {
+                stop: color['circle-radius'][i],
+                output: color['circle-radius'][i + 1]
+            };
+            stopOutputPairs.push(obj);
+        }
+        return stopOutputPairs;
+    };
+})(VectorUtils || (VectorUtils = {}));
+export var Utils;
+(function (Utils) {
+    Utils.getValueColorPairs = (stops, selectedRamp, nClasses) => {
+        let colorMap = colormap({
+            colormap: selectedRamp,
+            nshades: nClasses > 9 ? nClasses : 9,
+            format: 'rgba'
+        });
+        const valueColorPairs = [];
+        // colormap requires 9 classes to generate the ramp
+        // so we do some tomfoolery to make it work with less than 9 stops
+        if (nClasses < 9) {
+            const midIndex = Math.floor(nClasses / 2);
+            // Get the first n/2 elements from the second array
+            const firstPart = colorMap.slice(0, midIndex);
+            // Get the last n/2 elements from the second array
+            const secondPart = colorMap.slice(colorMap.length - (stops.length - firstPart.length));
+            // Create the new array by combining the first and last parts
+            colorMap = firstPart.concat(secondPart);
+        }
+        for (let i = 0; i < nClasses; i++) {
+            valueColorPairs.push({ stop: stops[i], output: colorMap[i] });
+        }
+        return valueColorPairs;
+    };
+})(Utils || (Utils = {}));

package/lib/dialogs/symbology/tiff_layer/TiffRendering.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ISymbologyDialogProps } from '../symbologyDialog';
+declare const TiffRendering: ({ context, state, okSignalPromise, cancel, layerId }: ISymbologyDialogProps) => React.JSX.Element;
+export default TiffRendering;

package/lib/dialogs/{components/symbology/BandRendering.js → symbology/tiff_layer/TiffRendering.js}

@@ -1,6 +1,6 @@
 import React, { useEffect, useState } from 'react';
-import SingleBandPseudoColor from './SingleBandPseudoColor';
-const BandRendering = ({ context, state, okSignalPromise, cancel, layerId }) => {
+import SingleBandPseudoColor from './types/SingleBandPseudoColor';
+const TiffRendering = ({ context, state, okSignalPromise, cancel, layerId }) => {
     const renderTypes = ['Singleband Pseudocolor', 'Multiband Color'];
     const [selectedRenderType, setSelectedRenderType] = useState('Singleband Pseudocolor');
     const [componentToRender, setComponentToRender] = useState(null);
@@ -26,4 +26,4 @@ const BandRendering = ({ context, state, okSignalPromise, cancel, layerId }) =>
                 } }, renderTypes.map((func, funcIndex) => (React.createElement("option", { key: func, value: func }, func))))),
         componentToRender));
 };
-export default BandRendering;
+export default TiffRendering;

package/lib/dialogs/{components/symbology → symbology/tiff_layer/components}/BandRow.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { IBandRow } from './SingleBandPseudoColor';
+import { IBandRow } from '../types/SingleBandPseudoColor';
 declare const BandRow: ({ index, bandRow, bandRows, setSelectedBand, setBandRows }: {
     index: number;
     bandRow: IBandRow;

package/lib/dialogs/{components/symbology → symbology/tiff_layer/types}/SingleBandPseudoColor.d.ts

@@ -11,6 +11,14 @@ export interface IBandRow {
         stdDev: number;
     };
     metadata: IDict;
+    histogram: IBandHistogram;
 }
-declare const SingleBandPseudoColor: ({ context, state, okSignalPromise, cancel, layerId }: ISymbologyDialogProps) => React.JSX.Element | undefined;
+export interface IBandHistogram {
+    buckets: number[];
+    count: number;
+    max: number;
+    min: number;
+}
+export type InterpolationType = 'discrete' | 'linear' | 'exact';
+declare const SingleBandPseudoColor: ({ context, okSignalPromise, cancel, layerId }: ISymbologyDialogProps) => React.JSX.Element | undefined;
 export default SingleBandPseudoColor;