leaflet-shadow-simulator 0.44.0 → 0.48.0

package/dist/shademap/leaflet-shademap/dist/ShadeMap.d.ts

@@ -0,0 +1,121 @@
+import { LatLngLiteral, Map as LeafletMap } from "leaflet";
+import { Map, MapboxGeoJSONFeature } from "mapbox-gl";
+import { BuildingRasterizer } from "./buildings/BuildingRasterizer";
+import { EventEmitter } from "./lib/EventEmitter";
+import { HeightMap } from "./lib/heightMap";
+import { TileMerger } from "./lib/TileMerger";
+import { LatLngBounds } from "./map/geometryLeaflet";
+import { UMap } from "./map/umap";
+import { CompiledKernel } from "./shader/kernel";
+import { Color } from "./types/color";
+import { DSMSource, SunExposureOptions, TerrainSource } from "./types/shadeMapOptions";
+export declare class ShadeMap extends EventEmitter {
+    _canvas: HTMLCanvasElement;
+    _gl: WebGLRenderingContext;
+    _map?: Map | LeafletMap;
+    _compiledKernel?: CompiledKernel;
+    _color: Color;
+    _bounds?: LatLngBounds;
+    _buildingRasterizer: BuildingRasterizer;
+    _tileMerger: TileMerger;
+    _heightMap?: HeightMap;
+    options: {
+        date: Date;
+        color: string;
+        opacity: number;
+        sunExposure: {
+            enabled: boolean;
+            startDate: Date;
+            endDate: Date;
+            iterations: number;
+        };
+        apiKey: string;
+        terrainSource: {
+            maxZoom: number;
+            tileSize: number;
+            _overzoom: number;
+            getSourceUrl: (params: {
+                x: number;
+                y: number;
+                z: number;
+            }) => string;
+            getElevation: (params: {
+                r: number;
+                g: number;
+                b: number;
+                a: number;
+            }) => number;
+        };
+        dsmSource: {
+            bounds: {
+                lat: number;
+                lng: number;
+            }[];
+            data: Uint8ClampedArray;
+            width: number;
+            height: number;
+            maxHeight: number;
+        };
+        belowCanopy: boolean;
+        getFeatures: () => Promise<MapboxGeoJSONFeature[]>;
+        getSize: () => {
+            width: number;
+            height: number;
+        };
+        debug: (msg: string) => void;
+    };
+    constructor(...args: any[]);
+    onRemove(): this;
+    setDate(date: Date): this;
+    _setDateForTimezone(date: Date, tzId?: string): void;
+    setColor(color: string): this;
+    setOpacity(opacity: number): this;
+    setBelowCanopy(belowCanopy: boolean): this;
+    setTerrainSource(terrainSource: TerrainSource): this;
+    setDSMSource(dsmSource: DSMSource): this;
+    setSunExposure(enabled?: boolean, options?: SunExposureOptions): Promise<this>;
+    _lngLatToTextureCoords(lngLat: LatLngLiteral[]): number[][];
+    _getBounds(map: UMap, demZoom: number): any;
+    _getDEMZoom(map: UMap): number;
+    _reset(): Promise<this>;
+    _draw(heightMap: HeightMap): Promise<this>;
+    readPixel(x: number, y: number): Uint8Array;
+    toGeoTiff(): {
+        data: Uint8Array;
+        metadata: {
+            width: number;
+            height: number;
+            ModelTiepoint: any[];
+            ModelPixelScale: number[];
+            GeographicTypeGeoKey: number;
+            GeogCitationGeoKey: string;
+        };
+    } | null;
+    _generateShadeProfile(params: {
+        locations: LatLngLiteral[];
+        dates: Date[];
+        sunColor: number[];
+        shadeColor: number[];
+    }): Uint8Array;
+    _generateLocationShadeProfile(params: {
+        location: LatLngLiteral;
+        startDate: Date;
+        endDate: Date;
+        sunColor: number[];
+        shadeColor: number[];
+        tzId: string;
+    }): {
+        data: Uint8Array;
+        width: number;
+        height: number;
+    };
+    getHoursOfSun(x: number, y: number): number;
+    _repositionCanvas(bounds: LatLngBounds): void;
+    _flush(): void;
+    flushSync(): void;
+    _parseColor(color: string): {
+        r: number;
+        g: number;
+        b: number;
+    };
+}

package/dist/shademap/leaflet-shademap/dist/ShadeMapLeaflet.d.ts

@@ -0,0 +1,14 @@
+import { Map } from "leaflet";
+import { CanvasOverlay } from "./components/CanvasOverlay";
+import { LatLngBounds } from "./map/geometryLeaflet";
+import { ShadeMap } from "./ShadeMap";
+import { ShadeMapOptions } from "./types/shadeMapOptions";
+declare class ShadeMapLeaflet extends ShadeMap {
+    _canvasOverlay?: CanvasOverlay;
+    constructor(options: ShadeMapOptions);
+    addTo(map: Map): this;
+    onAdd(map: Map): this;
+    _repositionCanvas(bounds: LatLngBounds): void;
+    _flush(): void;
+}
+export default ShadeMapLeaflet;

package/dist/shademap/leaflet-shademap/dist/ShadeMapMapbox.d.ts

@@ -0,0 +1,26 @@
+import { Map } from "mapbox-gl";
+import { LatLngBounds } from "./map/geometryLeaflet";
+import { ShadeMap } from "./ShadeMap";
+import { ShadeMapOptions } from "./types/shadeMapOptions";
+export default class extends ShadeMap {
+    id: string;
+    type: string;
+    canvasSourceId: string;
+    attributionSourceId: string;
+    canvasLayerId: string;
+    attributionLayerId: string;
+    _map?: Map;
+    _refreshing: number;
+    _raf: number;
+    _moveEndHandler: () => void;
+    constructor(options: ShadeMapOptions);
+    render(gl: WebGLRenderingContext, matrix: number[]): void;
+    addTo(map: Map): this;
+    onAdd(map: Map): this;
+    onRemove(): this;
+    _getHeightMapCoords(x: number, y: number): any;
+    getHoursOfSun(x: number, y: number): number;
+    remove(): void;
+    _flush(): void;
+    _repositionCanvas(bounds: LatLngBounds): this;
+}

package/dist/shademap/leaflet-shademap/dist/buildings/BuildingRasterizer.d.ts

@@ -0,0 +1,37 @@
+import { XYZ } from "../lib/helpers";
+import { DSMSource } from "../types/shadeMapOptions";
+interface BuildingRasterGLArgs {
+    upperLeftTile: XYZ;
+    features: {
+        aPosition: Float32Array;
+        cuts: Uint16Array | Uint8Array;
+        buildingHeight: number;
+        centroid: number[];
+        highlight: boolean;
+    }[];
+    mapZoom: number;
+    imageData: Uint8ClampedArray;
+    width: number;
+    height: number;
+    dsmSource: DSMSource;
+    dsmCoords: number[];
+    gl: WebGLRenderingContext;
+}
+export declare class BuildingRasterizer {
+    gl: WebGLRenderingContext;
+    program: WebGLProgram;
+    positionAttributeLocation: number;
+    dsmAttributeLocation: number;
+    useDSMUniformLocation: WebGLUniformLocation;
+    xyzUniformLocation: WebGLUniformLocation;
+    dimensionsUniformLocation: WebGLUniformLocation;
+    heightMapUniformLocation: WebGLUniformLocation;
+    colorUniformLocation: WebGLUniformLocation;
+    positionBuffer: WebGLBuffer;
+    dsmBuffer: WebGLBuffer;
+    indexBuffer: WebGLBuffer;
+    targetTexture: WebGLTexture;
+    constructor(gl: WebGLRenderingContext);
+    raster(args: BuildingRasterGLArgs): number;
+}
+export {};

package/dist/shademap/leaflet-shademap/dist/buildings/fetch-buildings.d.ts

@@ -0,0 +1,12 @@
+import { MapboxGeoJSONFeature } from "mapbox-gl";
+interface FetchBuildingsArgs {
+    getFeatures: () => Promise<MapboxGeoJSONFeature[]>;
+}
+export declare const fetchBuildings: (args: FetchBuildingsArgs) => Promise<{
+    aPosition: Float32Array;
+    cuts: Uint8Array | Uint16Array;
+    buildingHeight: number;
+    centroid: number[];
+    highlight: any;
+}[]>;
+export {};

package/dist/shademap/leaflet-shademap/dist/buildings/normalize-buildings.d.ts

@@ -0,0 +1,8 @@
+import { MapboxGeoJSONFeature } from "mapbox-gl";
+export declare function normalizeBuildings(features: MapboxGeoJSONFeature[]): {
+    aPosition: Float32Array;
+    cuts: Uint8Array | Uint16Array;
+    buildingHeight: number;
+    centroid: number[];
+    highlight: any;
+}[];

package/dist/shademap/leaflet-shademap/dist/components/CanvasOverlay.d.ts

@@ -0,0 +1,11 @@
+import { ImageOverlay, ImageOverlayOptions, LatLngBounds, LatLngBoundsExpression } from "leaflet";
+export declare class CanvasOverlay extends ImageOverlay {
+    _url: HTMLCanvasElement;
+    _image?: HTMLCanvasElement;
+    _zoomAnimated?: boolean;
+    _bounds?: LatLngBounds;
+    constructor(canvas: HTMLCanvasElement, bounds: LatLngBoundsExpression, options?: ImageOverlayOptions);
+    _initImage(): this;
+    setBounds(bounds: LatLngBounds): this;
+}
+export declare function canvasOverlay(...args: ConstructorParameters<typeof CanvasOverlay>): CanvasOverlay;

package/dist/shademap/leaflet-shademap/dist/index.d.ts

@@ -0,0 +1,7 @@
+import "leaflet";
+import ShadeMapLeaflet from "./ShadeMapLeaflet";
+import { ShadeMapOptions } from "./types/shadeMapOptions";
+declare module "leaflet" {
+    function shadeMap(options: ShadeMapOptions): ShadeMapLeaflet;
+}
+export { ShadeMapLeaflet as default, ShadeMapOptions };

package/dist/shademap/leaflet-shademap/dist/lib/EventEmitter.d.ts

@@ -0,0 +1,10 @@
+declare type Listener = (...args: any[]) => void;
+export declare class EventEmitter {
+    private readonly events;
+    on(event: string, listener: Listener): () => void;
+    removeListener(event: string, listener: Listener): void;
+    removeAllListeners(): void;
+    emit(event: string, ...args: any[]): void;
+    once(event: string, listener: Listener): () => void;
+}
+export {};

package/dist/shademap/leaflet-shademap/dist/lib/TileMerger.d.ts

@@ -0,0 +1,40 @@
+import { XYZRaster } from "./image";
+/**
+ * Notes:
+ *
+ * The responsibility of this code is to download map tiles and stitch
+ * them together into a bitmap
+ *
+ * The code can be aborted if a new set of tiles is requested
+ * The code works with 256x256 and 512x512 tiles
+ * Zoom can exceed a tileset's maximum value by cropping and scaling to the appropriate size
+ * Some tiles are virtual, they do not correspond to a physical image but are a subset of a physical image
+ */
+interface MergeImageOptions {
+    getSourceUrl: (params: {
+        x: number;
+        y: number;
+        z: number;
+    }) => string;
+    getElevation: (params: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }) => number;
+    width: number;
+    height: number;
+    crossOrigin?: string;
+    tileSize: number;
+    maxZoom: number;
+    tileLoaded: (loadedTiles: number, totalTiles: number) => void;
+}
+export declare class TileMerger {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    inProgress: HTMLImageElement[];
+    finished: number;
+    constructor();
+    merge(tiles: XYZRaster[], options: MergeImageOptions): Promise<Uint8ClampedArray | null>;
+}
+export {};

package/dist/shademap/leaflet-shademap/dist/lib/heightMap.d.ts

@@ -0,0 +1,33 @@
+import { MapboxGeoJSONFeature } from "mapbox-gl";
+import { BuildingRasterizer } from "../buildings/BuildingRasterizer";
+import { XYZRaster } from "../lib/image";
+import { TileMerger } from "./TileMerger";
+import { LatLngBounds, ValidBounds } from "../map/geometryLeaflet";
+import { DSMSource, TerrainSource } from "../types/shadeMapOptions";
+interface HeightMapParams {
+    terrainSource: TerrainSource;
+    dsmSource: DSMSource;
+    getFeatures: () => Promise<MapboxGeoJSONFeature[]>;
+    tileLoaded: (loadedTiles: number, totalTiles: number) => void;
+    gl: WebGLRenderingContext;
+    bounds: LatLngBounds;
+    buildingRasterizer: BuildingRasterizer;
+    tileMerger: TileMerger;
+    demZoom: number;
+    forceUpdate: boolean;
+}
+export interface HeightMap {
+    width: number;
+    height: number;
+    imageData: Uint8ClampedArray;
+    maxHeight: number;
+    visibleDEMPixelBounds: ValidBounds;
+    DEMPixelBounds: ValidBounds;
+    raster: XYZRaster[];
+    demZoom: number;
+    dirty: boolean;
+    outputWidth: number;
+    outputHeight: number;
+}
+export declare const getHeightMap: (params: HeightMapParams) => Promise<HeightMap>;
+export {};

package/dist/shademap/leaflet-shademap/dist/lib/helpers.d.ts

@@ -0,0 +1,27 @@
+import { Point, ValidBounds } from "../map/geometryLeaflet";
+export declare const pad: (x: number) => string | number;
+export interface XYZ {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface XYZParams {
+    upperLeft: Point;
+    width: number;
+    height: number;
+    zoom: number;
+}
+export declare const xyz: (params: XYZParams) => XYZ[];
+export interface TileBoundsArgs {
+    upperLeft: Point;
+    width: number;
+    height: number;
+}
+export declare const getTileBounds: (args: TileBoundsArgs) => ValidBounds;
+export declare const getDeclination: (date: Date) => {
+    dec: number;
+    Hi: number;
+};
+export declare const randomId: () => number;
+export declare const timeInTheSunMs: (exposureLayerColor: Uint8Array, exposureLayerOpacity: number, totalTimeIntervalInMs: number) => number;
+export declare const UTCOffsetByTimeZone: (date?: Date, timeZone?: string | undefined) => number;

package/dist/shademap/leaflet-shademap/dist/lib/image.d.ts

@@ -0,0 +1,13 @@
+import { XYZ } from "../lib/helpers";
+export interface XYZRaster {
+    xOffset: number;
+    yOffset: number;
+    x: number;
+    y: number;
+    z: number;
+}
+export declare const createTileRaster: (xyzTiles: XYZ[]) => XYZRaster[];
+export declare const getDimensions: (data: XYZRaster[]) => {
+    width: number;
+    height: number;
+};

package/dist/shademap/leaflet-shademap/dist/lib/projection.d.ts

@@ -0,0 +1,3 @@
+import { LatLngLiteral } from "leaflet";
+export declare const project: (center: LatLngLiteral, zoom: number) => any;
+export declare const unproject: (point: any, zoom: number) => any;

package/dist/shademap/leaflet-shademap/dist/lib/shadowMap.d.ts

@@ -0,0 +1,16 @@
+import { UMap } from "../map/umap";
+import { CompiledKernel } from "../shader/kernel";
+import { Color } from "../types/color";
+import { HeightMap } from "./heightMap";
+interface DrawShadowParams {
+    kernel: CompiledKernel;
+    map: UMap;
+    heightMap: HeightMap;
+    now: Date;
+    color: Color;
+    opacity: number;
+    maxZoom: number;
+    belowCanopy: boolean;
+}
+export declare const drawShadow: (params: DrawShadowParams) => void;
+export {};

package/dist/shademap/leaflet-shademap/dist/map/geometryLeaflet.d.ts

@@ -0,0 +1,11 @@
+import { LatLng } from "../../node_modules/leaflet/src/geo/LatLng";
+import { LatLngBounds } from "../../node_modules/leaflet/src/geo/LatLngBounds";
+import { Bounds } from "../../node_modules/leaflet/src/geometry/Bounds";
+import { Point } from "../../node_modules/leaflet/src/geometry/Point";
+export { Point, Bounds, LatLngBounds, LatLng };
+export interface ValidBounds extends Bounds {
+    getTopLeft: () => Point;
+    getBottomRight: () => Point;
+    min: Point;
+    max: Point;
+}

package/dist/shademap/leaflet-shademap/dist/map/umap.d.ts

@@ -0,0 +1,26 @@
+import { LatLngLiteral, Layer, Map as LeafletMap, PointExpression } from "leaflet";
+import { Map as MapboxGLMap } from "mapbox-gl";
+import { LatLng, LatLngBounds, Point } from "../map/geometryLeaflet";
+export interface UMap {
+    project: (center: LatLngLiteral, zoom: number) => Point;
+    unproject: (point: Point, zoom: number) => LatLng;
+    screenUnproject: (point: PointExpression) => LatLng;
+    getZoom: () => number;
+    getCenter: () => LatLng;
+    getBounds: () => LatLngBounds;
+    eachLayer(fn: (layer: Layer) => void): void;
+    getBearing: () => number;
+    getPitch: () => number;
+    rawMap: () => LeafletMap | MapboxGLMap;
+    isLeaflet: () => boolean;
+    getPixelDimensions: () => {
+        width: number;
+        height: number;
+    };
+    createBounds: (args: {
+        nw: LatLngLiteral;
+        se: LatLngLiteral;
+    }) => LatLngBounds;
+}
+declare const uMap: (map: MapboxGLMap | LeafletMap) => UMap;
+export default uMap;

package/dist/shademap/leaflet-shademap/dist/shader/gpu.d.ts

@@ -0,0 +1,29 @@
+import { Color } from "../types/color";
+import { Shadow3DData } from "../types/shadow3DData";
+import { CompiledKernel } from "./kernel";
+export declare const updateHeightMapGPU: (compiledKernel: CompiledKernel, shadow3DData: Shadow3DData) => void;
+export declare const updateDateGPU: (compiledKernel: CompiledKernel, params: {
+    date: Date;
+}) => void;
+export declare const generateShadeProfile: (compiledKernel: CompiledKernel, params: {
+    texCoords: number[][];
+    dates: Date[];
+    sunColor: number[];
+    shadeColor: number[];
+}) => Uint8Array;
+export declare const generateLocationShadeProfile: (compiledKernel: CompiledKernel, params: {
+    texCoord: number[];
+    dates: Date[][];
+    sunColor: number[];
+    shadeColor: number[];
+}) => Uint8Array;
+export declare const updateDateRangeGPU: (compiledKernel: CompiledKernel, params: {
+    startDate: Date;
+    endDate: Date;
+    iterations: number;
+    emit: (name: string, ...args: any[]) => void;
+}) => Promise<boolean>;
+export declare const updateColorGPU: (compiledKernel: CompiledKernel, params: {
+    color: Color;
+    opacity: number;
+}) => void;

package/dist/shademap/leaflet-shademap/dist/shader/kernel.d.ts

@@ -0,0 +1,68 @@
+interface CompileProgramArgs {
+    gl: WebGLRenderingContext;
+    vSrc: string;
+    fSrc: string;
+}
+interface UpdateLocationArgs {
+    width: number;
+    height: number;
+    maxHeight: number;
+    heightMapZoom: number;
+    topYCoord: number;
+    ySize: number;
+    colorVec: number[];
+    step: number;
+    west: number;
+    dLng: number;
+    dec: number;
+    Hi: number;
+    cornerClipCoords: number[];
+    cornerTextureCoords: number[];
+    outputWidth: number;
+    outputHeight: number;
+    belowCanopy: boolean;
+}
+interface UpdateViewportArgs {
+    xStart: number;
+    yStart: number;
+    xEnd: number;
+    yEnd: number;
+}
+interface UpdateDateArgs {
+    dec: number;
+    Hi: number;
+}
+interface UpdateDateRangeArgs {
+    startDate: Date;
+    endDate: Date;
+    iterations: number;
+    emit: (name: string, ...args: any[]) => void;
+}
+interface UpdateColorArgs {
+    colorVec: number[];
+}
+export interface CompiledKernel {
+    updateLocation: (args: UpdateLocationArgs) => void;
+    updateViewport: (args: UpdateViewportArgs) => void;
+    updateDate: (args: UpdateDateArgs) => void;
+    updateDateRange: (args: UpdateDateRangeArgs) => Promise<boolean>;
+    updateColor: (args: UpdateColorArgs) => void;
+    generateShadeProfile: (args: {
+        texCoords: number[][];
+        dates: Date[];
+        sunColor: number[];
+        shadeColor: number[];
+    }) => Uint8Array;
+    generateLocationShadeProfile: (args: {
+        texCoord: number[];
+        dates: Date[][];
+        sunColor: number[];
+        shadeColor: number[];
+    }) => Uint8Array;
+}
+export declare function compileProgram(args: CompileProgramArgs): WebGLProgram;
+interface Settings {
+    context: WebGLRenderingContext;
+}
+declare function kernel(settings: Settings): CompiledKernel;
+export default kernel;

package/dist/shademap/leaflet-shademap/dist/types/color.d.ts

@@ -0,0 +1,5 @@
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+}

package/dist/shademap/leaflet-shademap/dist/types/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_ELEVATION = 8848;
+export declare const TILE_SIZE = 256;
+export declare const EXPOSURE_LAYER_OPACITY = 0.5;

package/dist/shademap/leaflet-shademap/dist/types/quality.d.ts

@@ -0,0 +1,5 @@
+export declare enum Quality {
+    LOW = "low",
+    MED = "medium",
+    HIGH = "high"
+}

package/dist/shademap/leaflet-shademap/dist/types/shadeMapOptions.d.ts

@@ -0,0 +1,46 @@
+import { MapboxGeoJSONFeature } from "mapbox-gl";
+import { Quality } from "./quality";
+import { LatLngLiteral } from "leaflet";
+export interface TerrainSource {
+    maxZoom: number;
+    tileSize: number;
+    getSourceUrl: (params: {
+        x: number;
+        y: number;
+        z: number;
+    }) => string;
+    getElevation: (params: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }) => number;
+    _overzoom: number;
+}
+export interface DSMSource {
+    data: Uint8ClampedArray;
+    bounds: LatLngLiteral[];
+    width: number;
+    height: number;
+    maxHeight: number;
+}
+export interface SunExposureOptions {
+    startDate: Date;
+    endDate: Date;
+    iterations?: number;
+}
+export interface SunExposure extends SunExposureOptions {
+    enabled: boolean;
+}
+export interface ShadeMapOptions {
+    date?: Date;
+    color?: string;
+    opacity?: number;
+    quality?: Quality;
+    sunExposure?: SunExposure;
+    terrainSource?: TerrainSource;
+    dsmSource?: DSMSource;
+    getFeatures?: () => Promise<MapboxGeoJSONFeature[]>;
+    apiKey: string;
+    debug?: (msg: string) => void;
+}

package/dist/shademap/leaflet-shademap/dist/types/shadow3DData.d.ts

@@ -0,0 +1,20 @@
+import { Color } from "./color";
+export interface Shadow3DData {
+    imageData: Uint8ClampedArray;
+    maxHeight: number;
+    width: number;
+    height: number;
+    date: Date;
+    heightMapZoom: number;
+    topYCoord: number;
+    ySize: number;
+    color: Color;
+    opacity: number;
+    west: number;
+    dLng: number;
+    cornerClipCoords: number[];
+    cornerTextureCoords: number[];
+    outputWidth: number;
+    outputHeight: number;
+    belowCanopy: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leaflet-shadow-simulator",
-  "version": "0.44.0",
+  "version": "0.48.0",
   "description": "Display terrain and structure shadows cast by the sun in a custom Leaflet layer",
   "main": "dist/leaflet-shadow-simulator.umd.min.js",
   "browser": "dist/leaflet-shadow-simulator.umd.min.js",