@jupytergis/base 0.9.1 → 0.10.0

package/style/icons/logo_mini.svg

@@ -11,7 +11,7 @@
    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
    xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
+>
   <defs
      class="jp-icon-selectable jgis-main-logo">
     <clipPath

package/style/icons/marker.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640">
+    <!--!Font Awesome Free 7.1.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.-->
+<path fill="{{COLOR}}" d="M128 252.6C128 148.4 214 64 320 64C426 64 512 148.4 512 252.6C512 371.9 391.8 514.9 341.6 569.4C329.8 582.2 310.1 582.2 298.3 569.4C248.1 514.9 127.9 371.9 127.9 252.6zM320 320C355.3 320 384 291.3 384 256C384 220.7 355.3 192 320 192C284.7 192 256 220.7 256 256C256 291.3 284.7 320 320 320z"/>
+
+</svg>

package/style/icons/target_without_center.svg

@@ -4,7 +4,7 @@
    version="1.1"
    id="svg1"
    xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
+>
   <defs
      id="defs1" />
   <!--!Font Awesome Free 6.7.2 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2025 Fonticons, Inc.-->

package/style/icons/vector_square.svg

@@ -5,7 +5,7 @@
    version="1.1"
    id="svg1"
    xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
+>
    <defs
       id="defs1" />
    <!--!Font

package/style/shared/tabs.css

@@ -21,6 +21,7 @@
   width: 100%;
   font-size: 9px;
   border-radius: 5px;
+  overflow-x: scroll;
 }
 
 .jgis-tabs-trigger {

package/style/symbologyDialog.css

@@ -158,9 +158,9 @@ select option {
   border: var(--jp-border-width) solid var(--jp-input-border-color);
   border-radius: 0;
   outline: none;
-  appearance: none;
   -webkit-appearance: none;
   -moz-appearance: none;
+  appearance: none;
 }
 
 .jp-gis-open {
@@ -172,20 +172,25 @@ select option {
   align-items: center;
   font-size: var(--jp-ui-font-size2);
   color: var(--jp-ui-font-color0);
-  appearance: none;
   text-transform: capitalize;
   cursor: pointer;
+  position: relative;
   -webkit-appearance: none;
   -moz-appearance: none;
+  appearance: none;
 }
 
 .jp-gis-color-label {
   color: white;
+  padding-left: 10px;
   position: absolute;
+  text-shadow: 0px 0px 4px black;
+
   transition: transform 0.3s ease;
+  transform-origin: left bottom;
 }
 
-.jp-gis-color-ramp-entry:hover .jp-gis-color-label {
+.jp-gis-color-ramp-entry:not(.jp-gis-selected-entry):hover .jp-gis-color-label {
   transform: scale(1.2);
 }
 
@@ -215,8 +220,11 @@ select option {
 }
 
 #jp-gis-canvas-button.jp-gis-canvas-button {
-  visibility: hidden;
   margin: 0;
   padding: 0 1px 0 0;
   width: 100%;
 }
+
+.jp-gis-selected-entry {
+  width: 100%;
+}

package/lib/classificationModes.d.ts

@@ -1,13 +0,0 @@
-import { InterpolationType } from './dialogs/symbology/tiff_layer/types/SingleBandPseudoColor';
-export declare namespace VectorClassifications {
-    const calculateQuantileBreaks: (values: number[], nClasses: number) => number[];
-    const calculateEqualIntervalBreaks: (values: number[], nClasses: number) => number[];
-    const calculateJenksBreaks: (values: number[], nClasses: number) => any[];
-    const calculatePrettyBreaks: (values: number[], nClasses: number) => number[];
-    const calculateLogarithmicBreaks: (values: number[], nClasses: number) => number[];
-}
-export declare namespace GeoTiffClassifications {
-    const classifyQuantileBreaks: (nClasses: number, bandNumber: number, url: string, colorRampType: string) => Promise<number[]>;
-    const classifyContinuousBreaks: (nClasses: number, minimumValue: number, maximumValue: number, colorRampType: InterpolationType) => number[];
-    const classifyEqualIntervalBreaks: (nClasses: number, minimumValue: number, maximumValue: number, colorRampType: InterpolationType) => number[];
-}

package/lib/classificationModes.js

@@ -1,326 +0,0 @@
-// Adapted from https://github.com/qgis/QGIS/blob/master/src/core/classification/
-import { Pool, fromUrl } from 'geotiff';
-export var VectorClassifications;
-(function (VectorClassifications) {
-    VectorClassifications.calculateQuantileBreaks = (values, nClasses) => {
-        // q-th quantile of a data set:
-        // value where q fraction of data is below and (1-q) fraction is above this value
-        // Xq = (1 - r) * X_NI1 + r * X_NI2
-        //   NI1 = (int) (q * (n+1))
-        //   NI2 = NI1 + 1
-        //   r = q * (n+1) - (int) (q * (n+1))
-        // (indices of X: 1...n)
-        const sortedValues = [...values].sort((a, b) => a - b);
-        const breaks = [];
-        if (!sortedValues) {
-            return [];
-        }
-        const n = sortedValues.length;
-        let xq = n > 0 ? sortedValues[0] : 0;
-        for (let i = 1; i < nClasses; i++) {
-            if (n > 1) {
-                const q = i / nClasses;
-                const a = q * (n - 1);
-                const aa = Math.floor(a);
-                const r = a - aa;
-                xq = (1 - r) * sortedValues[aa] + r * sortedValues[aa + 1];
-            }
-            breaks.push(xq);
-        }
-        breaks.push(sortedValues[n - 1]);
-        return breaks;
-    };
-    VectorClassifications.calculateEqualIntervalBreaks = (values, nClasses) => {
-        const minimum = Math.min(...values);
-        const maximum = Math.max(...values);
-        const breaks = [];
-        const step = (maximum - minimum) / nClasses;
-        let value = minimum;
-        for (let i = 0; i < nClasses; i++) {
-            value += step;
-            breaks.push(value);
-        }
-        breaks[nClasses - 1] = maximum;
-        return breaks;
-    };
-    VectorClassifications.calculateJenksBreaks = (values, nClasses) => {
-        const maximum = Math.max(...values);
-        if (values.length === 0) {
-            return [];
-        }
-        if (nClasses <= 1) {
-            return [maximum];
-        }
-        if (nClasses >= values.length) {
-            return values;
-        }
-        const sample = [...values].sort((a, b) => a - b);
-        const n = sample.length;
-        const matrixOne = Array.from({ length: n + 1 }, () => Array(nClasses + 1).fill(0));
-        const matrixTwo = Array.from({ length: n + 1 }, () => Array(nClasses + 1).fill(Number.MAX_VALUE));
-        for (let i = 1; i <= nClasses; i++) {
-            matrixOne[0][i] = 1;
-            matrixOne[1][i] = 1;
-            matrixTwo[0][i] = 0.0;
-            for (let j = 2; j <= n; j++) {
-                matrixTwo[j][i] = Number.MAX_VALUE;
-            }
-        }
-        for (let l = 2; l <= n; l++) {
-            let s1 = 0.0;
-            let s2 = 0.0;
-            let w = 0;
-            let v = 0.0;
-            for (let m = 1; m <= l; m++) {
-                const i3 = l - m + 1;
-                const val = sample[i3 - 1];
-                s2 += val * val;
-                s1 += val;
-                w++;
-                v = s2 - (s1 * s1) / w;
-                const i4 = i3 - 1;
-                if (i4 !== 0) {
-                    for (let j = 2; j <= nClasses; j++) {
-                        if (matrixTwo[l][j] >= v + matrixTwo[i4][j - 1]) {
-                            matrixOne[l][j] = i4;
-                            matrixTwo[l][j] = v + matrixTwo[i4][j - 1];
-                        }
-                    }
-                }
-            }
-            matrixOne[l][1] = 1;
-            matrixTwo[l][1] = v;
-        }
-        const breaks = Array(nClasses);
-        breaks[nClasses - 1] = sample[n - 1];
-        for (let j = nClasses, k = n; j >= 2; j--) {
-            const id = matrixOne[k][j] - 1;
-            breaks[j - 2] = sample[id];
-            k = matrixOne[k][j] - 1;
-        }
-        return breaks;
-    };
-    VectorClassifications.calculatePrettyBreaks = (values, nClasses) => {
-        const minimum = Math.min(...values);
-        const maximum = Math.max(...values);
-        const breaks = [];
-        if (nClasses < 1) {
-            breaks.push(maximum);
-            return breaks;
-        }
-        const minimumCount = Math.floor(nClasses / 3);
-        const shrink = 0.75;
-        const highBias = 1.5;
-        const adjustBias = 0.5 + 1.5 * highBias;
-        const divisions = nClasses;
-        const h = highBias;
-        let cell;
-        let small = false;
-        const dx = maximum - minimum;
-        let U;
-        cell = Math.max(Math.abs(minimum), Math.abs(maximum));
-        if (adjustBias >= 1.5 * h + 0.5) {
-            U = 1 + 1.0 / (1 + h);
-        }
-        else {
-            U = 1 + 1.5 / (1 + adjustBias);
-        }
-        small = dx < cell * U * Math.max(1, divisions) * 1e-7 * 3.0;
-        if (small) {
-            if (cell > 10) {
-                cell = 9 + cell / 10;
-                cell = cell * shrink;
-            }
-            if (minimumCount > 1) {
-                cell = cell / minimumCount;
-            }
-        }
-        else {
-            cell = dx;
-            if (divisions > 1) {
-                cell = cell / divisions;
-            }
-        }
-        if (cell < 20 * 1e-7) {
-            cell = 20 * 1e-7;
-        }
-        const base = Math.pow(10.0, Math.floor(Math.log10(cell)));
-        let unit = base;
-        if (2 * base - cell < h * (cell - unit)) {
-            unit = 2.0 * base;
-            if (5 * base - cell < adjustBias * (cell - unit)) {
-                unit = 5.0 * base;
-                if (10.0 * base - cell < h * (cell - unit)) {
-                    unit = 10.0 * base;
-                }
-            }
-        }
-        let start = Math.floor(minimum / unit + 1e-7);
-        let end = Math.ceil(maximum / unit - 1e-7);
-        while (start * unit > minimum + 1e-7 * unit) {
-            start = start - 1;
-        }
-        while (end * unit < maximum - 1e-7 * unit) {
-            end = end + 1;
-        }
-        let k = Math.floor(0.5 + end - start);
-        if (k < minimumCount) {
-            k = minimumCount - k;
-            if (start >= 0) {
-                end = end + k / 2;
-                start = start - k / 2 + (k % 2);
-            }
-            else {
-                start = start - k / 2;
-                end = end + k / 2 + (k % 2);
-            }
-        }
-        const minimumBreak = start * unit;
-        const count = end - start;
-        for (let i = 1; i < count + 1; i++) {
-            breaks.push(minimumBreak + i * unit);
-        }
-        if (breaks.length === 0) {
-            return breaks;
-        }
-        if (breaks[0] < minimum) {
-            breaks[0] = minimum;
-        }
-        if (breaks[breaks.length - 1] > maximum) {
-            breaks[breaks.length - 1] = maximum;
-        }
-        if (minimum < 0.0 && maximum > 0.0) {
-            const breaksMinusZero = breaks.map(b => b - 0.0);
-            let posOfMin = 0;
-            for (let i = 1; i < breaks.length; i++) {
-                if (Math.abs(breaksMinusZero[i]) < Math.abs(breaksMinusZero[posOfMin])) {
-                    posOfMin = i;
-                }
-            }
-            breaks[posOfMin] = 0.0; // Set the closest break to zero
-        }
-        return breaks;
-    };
-    VectorClassifications.calculateLogarithmicBreaks = (values, nClasses) => {
-        const minimum = Math.min(...values);
-        const maximum = Math.max(...values);
-        let positiveMinimum = Number.MAX_VALUE;
-        let breaks = [];
-        positiveMinimum = minimum;
-        const actualLogMin = Math.log10(positiveMinimum);
-        let logMin = Math.floor(actualLogMin);
-        const logMax = Math.ceil(Math.log10(maximum));
-        let prettyBreaks = VectorClassifications.calculatePrettyBreaks([logMin, logMax], nClasses);
-        while (prettyBreaks.length > 0 && prettyBreaks[0] < actualLogMin) {
-            logMin += 1.0;
-            prettyBreaks = VectorClassifications.calculatePrettyBreaks([logMin, logMax], nClasses);
-        }
-        breaks = prettyBreaks;
-        for (let i = 0; i < breaks.length; i++) {
-            breaks[i] = Math.pow(10, breaks[i]);
-        }
-        return breaks;
-    };
-})(VectorClassifications || (VectorClassifications = {}));
-export var GeoTiffClassifications;
-(function (GeoTiffClassifications) {
-    GeoTiffClassifications.classifyQuantileBreaks = async (nClasses, bandNumber, url, colorRampType) => {
-        const breaks = [];
-        const isDiscrete = colorRampType === 'discrete';
-        const pool = new Pool();
-        const tiff = await fromUrl(url);
-        const image = await tiff.getImage();
-        const values = await image.readRasters({ pool });
-        // Band numbers are 1 indexed
-        const bandValues = values[bandNumber - 1];
-        const bandSortedValues = bandValues
-            .filter(value => value !== 0)
-            .sort((a, b) => a - b);
-        pool.destroy();
-        if (!bandSortedValues) {
-            return [];
-        }
-        // Adapted from https://github.com/GeoTIFF/geoblaze/blob/master/src/histogram/histogram.core.js#L64
-        // iterate through values and use a counter to
-        // decide when to set up the next bin.
-        let numValuesInCurrentBin;
-        let valuesPerBin;
-        let startIndex;
-        if (isDiscrete) {
-            valuesPerBin = bandSortedValues.length / nClasses;
-            numValuesInCurrentBin = 0;
-            startIndex = 0;
-        }
-        else {
-            valuesPerBin = bandSortedValues.length / (nClasses - 1);
-            breaks.push(1);
-            numValuesInCurrentBin = 1;
-            startIndex = 1;
-        }
-        for (let i = startIndex; i < bandSortedValues.length; i++) {
-            if (numValuesInCurrentBin + 1 < valuesPerBin) {
-                numValuesInCurrentBin++;
-            }
-            else {
-                breaks.push(bandSortedValues[i]);
-                numValuesInCurrentBin = 0;
-            }
-        }
-        if (breaks.length !== nClasses) {
-            //TODO: This should be set based on the type of bandSortedValues I think
-            breaks.push(65535);
-        }
-        return breaks;
-    };
-    GeoTiffClassifications.classifyContinuousBreaks = (nClasses, minimumValue, maximumValue, colorRampType) => {
-        const min = minimumValue;
-        const max = maximumValue;
-        if (min > max) {
-            return [];
-        }
-        const isDiscrete = colorRampType === 'discrete';
-        const breaks = [];
-        const numberOfEntries = nClasses;
-        if (isDiscrete) {
-            const intervalDiff = ((max - min) * (numberOfEntries - 1)) / numberOfEntries;
-            for (let i = 1; i < numberOfEntries; i++) {
-                const val = i / numberOfEntries;
-                breaks.push(min + val * intervalDiff);
-            }
-            breaks.push(max);
-        }
-        else {
-            for (let i = 0; i <= numberOfEntries; i++) {
-                if (i === 26) {
-                    continue;
-                }
-                const val = i / numberOfEntries;
-                breaks.push(min + val * (max - min));
-            }
-        }
-        return breaks;
-    };
-    GeoTiffClassifications.classifyEqualIntervalBreaks = (nClasses, minimumValue, maximumValue, colorRampType) => {
-        const min = minimumValue;
-        const max = maximumValue;
-        if (min > max) {
-            return [];
-        }
-        const isDiscrete = colorRampType === 'discrete';
-        const breaks = [];
-        if (isDiscrete) {
-            const intervalDiff = (max - min) / nClasses;
-            for (let i = 1; i < nClasses; i++) {
-                breaks.push(min + i * intervalDiff);
-            }
-            breaks.push(max);
-        }
-        else {
-            const intervalDiff = (max - min) / (nClasses - 1);
-            for (let i = 0; i < nClasses; i++) {
-                breaks.push(min + i * intervalDiff);
-            }
-        }
-        return breaks;
-    };
-})(GeoTiffClassifications || (GeoTiffClassifications = {}));

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

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

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

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

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

@@ -1,32 +0,0 @@
-import { Button } from '@jupyterlab/ui-components';
-import React, { useEffect, useState } from 'react';
-import { LoadingIcon } from "../../../../shared/components/loading";
-import CanvasSelectComponent from './CanvasSelectComponent';
-import ModeSelectRow from './ModeSelectRow';
-const ColorRamp = ({ layerParams, modeOptions, classifyFunc, showModeRow, showRampSelector, }) => {
-    const [selectedRamp, setSelectedRamp] = useState('');
-    const [selectedMode, setSelectedMode] = useState('');
-    const [numberOfShades, setNumberOfShades] = useState('');
-    const [isLoading, setIsLoading] = useState(false);
-    useEffect(() => {
-        populateOptions();
-    }, [layerParams]);
-    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 : 'viridis');
-    };
-    return (React.createElement("div", { className: "jp-gis-color-ramp-container" },
-        showRampSelector && (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(LoadingIcon, null)) : (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

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