@jupytergis/base 0.1.6 → 0.2.0

package/lib/annotations/components/Annotation.d.ts

@@ -0,0 +1,11 @@
+import { IAnnotationModel } from '@jupytergis/schema';
+import React from 'react';
+import { IControlPanelModel } from '../../types';
+export interface IAnnotationProps {
+    itemId: string;
+    annotationModel: IAnnotationModel;
+    rightPanelModel?: IControlPanelModel;
+    children?: JSX.Element[] | JSX.Element;
+}
+declare const Annotation: ({ itemId, annotationModel, rightPanelModel, children }: IAnnotationProps) => React.JSX.Element;
+export default Annotation;

package/lib/annotations/components/Annotation.js

@@ -0,0 +1,61 @@
+import { faTrash, faPaperPlane, faArrowsToDot } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { showDialog, Dialog } from '@jupyterlab/apputils';
+import { Button } from '@jupyterlab/ui-components';
+import React, { useMemo, useState } from 'react';
+import { Message } from './Message';
+const Annotation = ({ itemId, annotationModel, rightPanelModel, children }) => {
+    const [messageContent, setMessageContent] = useState('');
+    const [jgisModel, setJgisModel] = useState(rightPanelModel === null || rightPanelModel === void 0 ? void 0 : rightPanelModel.jGISModel);
+    const annotation = annotationModel.getAnnotation(itemId);
+    const contents = useMemo(() => { var _a; return (_a = annotation === null || annotation === void 0 ? void 0 : annotation.contents) !== null && _a !== void 0 ? _a : []; }, [annotation]);
+    /**
+     * Update the model when it changes.
+     */
+    rightPanelModel === null || rightPanelModel === void 0 ? void 0 : rightPanelModel.documentChanged.connect((_, widget) => {
+        setJgisModel(widget === null || widget === void 0 ? void 0 : widget.context.model);
+    });
+    const handleSubmit = () => {
+        annotationModel.addContent(itemId, messageContent);
+        setMessageContent('');
+    };
+    const handleDelete = async () => {
+        var _a;
+        // If the annotation has no content
+        // we remove it right away without prompting
+        if (!((_a = annotationModel.getAnnotation(itemId)) === null || _a === void 0 ? void 0 : _a.contents.length)) {
+            return annotationModel.removeAnnotation(itemId);
+        }
+        const result = await showDialog({
+            title: 'Delete Annotation',
+            body: 'Are you sure you want to delete this annotation?',
+            buttons: [Dialog.cancelButton(), Dialog.okButton({ label: 'Delete' })]
+        });
+        if (result.button.accept) {
+            annotationModel.removeAnnotation(itemId);
+        }
+    };
+    const centerOnAnnotation = () => {
+        jgisModel === null || jgisModel === void 0 ? void 0 : jgisModel.centerOnAnnotation(itemId);
+    };
+    return (React.createElement("div", { className: "jGIS-Annotation" },
+        children,
+        React.createElement("div", null, contents.map(content => {
+            var _a, _b;
+            return (React.createElement(Message, { user: content.user, message: content.value, self: ((_a = annotationModel.user) === null || _a === void 0 ? void 0 : _a.username) === ((_b = content.user) === null || _b === void 0 ? void 0 : _b.username) }));
+        })),
+        React.createElement("div", { className: "jGIS-Annotation-Message" },
+            React.createElement("textarea", { rows: 3, placeholder: 'Ctrl+Enter to submit', value: messageContent, onChange: e => setMessageContent(e.currentTarget.value), onKeyDown: e => {
+                    if (e.ctrlKey && e.key === 'Enter') {
+                        handleSubmit();
+                    }
+                } })),
+        React.createElement("div", { className: "jGIS-Annotation-Buttons" },
+            React.createElement(Button, { className: "jp-mod-styled jp-mod-warn", onClick: handleDelete },
+                React.createElement(FontAwesomeIcon, { icon: faTrash })),
+            rightPanelModel && (React.createElement(Button, { className: "jp-mod-styled jp-mod-accept", onClick: centerOnAnnotation },
+                React.createElement(FontAwesomeIcon, { icon: faArrowsToDot }))),
+            React.createElement(Button, { className: "jp-mod-styled jp-mod-accept", onClick: handleSubmit },
+                React.createElement(FontAwesomeIcon, { icon: faPaperPlane })))));
+};
+export default Annotation;

package/lib/annotations/components/AnnotationFloater.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { IAnnotationProps } from './Annotation';
+interface IAnnotationFloaterProps extends IAnnotationProps {
+    open: boolean;
+}
+declare const AnnotationFloater: ({ itemId, annotationModel: model, open }: IAnnotationFloaterProps) => React.JSX.Element;
+export default AnnotationFloater;

package/lib/annotations/components/AnnotationFloater.js

@@ -0,0 +1,30 @@
+import React, { useState } from 'react';
+import { faWindowMinimize } from '@fortawesome/free-solid-svg-icons';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import Annotation from './Annotation';
+const AnnotationFloater = ({ itemId, annotationModel: model, open }) => {
+    const [isOpen, setIsOpen] = useState(open);
+    // Function that either
+    // - opens the annotation if `open`
+    // - removes the annotation if `!open` and the annotation is empty
+    // - closes the annotation if `!open` and the annotation is not empty
+    const setOpenOrDelete = (open) => {
+        var _a;
+        if (open) {
+            return setIsOpen(true);
+        }
+        if (!((_a = model.getAnnotation(itemId)) === null || _a === void 0 ? void 0 : _a.contents.length)) {
+            return model.removeAnnotation(itemId);
+        }
+        setIsOpen(false);
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "jGIS-Annotation-Handler", onClick: () => setOpenOrDelete(!isOpen) }),
+        React.createElement("div", { className: "jGIS-FloatingAnnotation", style: { visibility: isOpen ? 'visible' : 'hidden' } },
+            React.createElement(Annotation, { itemId: itemId, annotationModel: model },
+                React.createElement("div", { className: "jGIS-Popup-Topbar", onClick: () => {
+                        setOpenOrDelete(false);
+                    } },
+                    React.createElement(FontAwesomeIcon, { icon: faWindowMinimize, className: "jGIS-Popup-TopBarIcon" }))))));
+};
+export default AnnotationFloater;

package/lib/annotations/components/Message.d.ts

@@ -0,0 +1,8 @@
+import { User } from '@jupyterlab/services';
+interface IProps {
+    message: string;
+    self: boolean;
+    user?: User.IIdentity;
+}
+export declare const Message: (props: IProps) => JSX.Element;
+export {};

package/lib/annotations/components/Message.js

@@ -0,0 +1,17 @@
+import React from 'react';
+export const Message = (props) => {
+    var _a, _b, _c;
+    const { self, message, user } = props;
+    const color = (_a = user === null || user === void 0 ? void 0 : user.color) !== null && _a !== void 0 ? _a : 'black';
+    const author = (_b = user === null || user === void 0 ? void 0 : user.display_name) !== null && _b !== void 0 ? _b : '';
+    const initials = (_c = user === null || user === void 0 ? void 0 : user.initials) !== null && _c !== void 0 ? _c : '';
+    return (React.createElement("div", { className: "jGIS-Annotation-Message", style: {
+            flexFlow: self ? 'row' : 'row-reverse'
+        } },
+        React.createElement("div", { className: "jGIS-Annotation-User-Icon", style: {
+                backgroundColor: color
+            }, title: author },
+            React.createElement("span", { style: { width: 24, textAlign: 'center' } }, initials)),
+        React.createElement("div", { className: "jGIS-Annotation-Message-Content" },
+            React.createElement("p", { style: { padding: 7, margin: 0 } }, message))));
+};

package/lib/annotations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './model';
+export * from './components/Annotation';
+export * from './components/AnnotationFloater';

package/lib/annotations/index.js

@@ -0,0 +1,3 @@
+export * from './model';
+export * from './components/Annotation';
+export * from './components/AnnotationFloater';

package/lib/annotations/model.d.ts

@@ -0,0 +1,28 @@
+import { IAnnotation, IAnnotationModel, IJupyterGISModel } from '@jupytergis/schema';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { User } from '@jupyterlab/services';
+import { ISignal } from '@lumino/signaling';
+export declare class AnnotationModel implements IAnnotationModel {
+    constructor(options: AnnotationModel.IOptions);
+    get updateSignal(): ISignal<this, null>;
+    get user(): User.IIdentity | undefined;
+    set context(context: DocumentRegistry.IContext<IJupyterGISModel> | undefined);
+    get context(): DocumentRegistry.IContext<IJupyterGISModel> | undefined;
+    get contextChanged(): ISignal<this, void>;
+    update(): void;
+    getAnnotation(id: string): IAnnotation | undefined;
+    getAnnotationIds(): string[];
+    addAnnotation(key: string, value: IAnnotation): void;
+    removeAnnotation(key: string): void;
+    addContent(id: string, value: string): void;
+    private _context;
+    private _contextChanged;
+    private _updateSignal;
+    private _user?;
+}
+declare namespace AnnotationModel {
+    interface IOptions {
+        context: DocumentRegistry.IContext<IJupyterGISModel> | undefined;
+    }
+}
+export {};

package/lib/annotations/model.js

@@ -0,0 +1,67 @@
+import { Signal } from '@lumino/signaling';
+export class AnnotationModel {
+    constructor(options) {
+        this._contextChanged = new Signal(this);
+        this._updateSignal = new Signal(this);
+        this.context = options.context;
+    }
+    get updateSignal() {
+        return this._updateSignal;
+    }
+    get user() {
+        return this._user;
+    }
+    set context(context) {
+        var _a;
+        this._context = context;
+        const state = (_a = this._context) === null || _a === void 0 ? void 0 : _a.model.sharedModel.awareness.getLocalState();
+        this._user = state === null || state === void 0 ? void 0 : state.user;
+        this._contextChanged.emit(void 0);
+    }
+    get context() {
+        return this._context;
+    }
+    get contextChanged() {
+        return this._contextChanged;
+    }
+    update() {
+        this._updateSignal.emit(null);
+    }
+    getAnnotation(id) {
+        var _a;
+        const rawData = (_a = this._context) === null || _a === void 0 ? void 0 : _a.model.sharedModel.getMetadata(id);
+        if (rawData) {
+            return JSON.parse(rawData);
+        }
+    }
+    getAnnotationIds() {
+        var _a;
+        const annotationIds = [];
+        for (const id in (_a = this._context) === null || _a === void 0 ? void 0 : _a.model.sharedModel.metadata) {
+            if (id.startsWith('annotation')) {
+                annotationIds.push(id);
+            }
+        }
+        return annotationIds;
+    }
+    addAnnotation(key, value) {
+        var _a;
+        (_a = this._context) === null || _a === void 0 ? void 0 : _a.model.sharedModel.setMetadata(`annotation_${key}`, JSON.stringify(value));
+    }
+    removeAnnotation(key) {
+        var _a;
+        (_a = this._context) === null || _a === void 0 ? void 0 : _a.model.removeMetadata(key);
+    }
+    addContent(id, value) {
+        var _a;
+        const newContent = {
+            value,
+            user: this._user
+        };
+        const currentAnnotation = this.getAnnotation(id);
+        if (currentAnnotation) {
+            const newAnnotation = Object.assign(Object.assign({}, currentAnnotation), { contents: [...currentAnnotation.contents, newContent] });
+            (_a = this._context) === null || _a === void 0 ? void 0 : _a.model.sharedModel.setMetadata(id, JSON.stringify(newAnnotation));
+        }
+    }
+}

package/lib/classificationModes.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,326 @@
+// 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 = {}));