raain-ui 1.0.15

package/README.md

@@ -0,0 +1,19 @@
+# raain-ui
+
+Please read the [specifications](./specs).
+
+or try the [example](./example) :
+```bash
+npm i
+npm run build
+cd example/
+npm start 
+```
+=> http://localhost:1234
+
+## History
+
+See [Release notes](./RELEASE.md).
+
+## License
+MIT

package/RELEASE.md

@@ -0,0 +1,3 @@
+# Release notes
+
+ - v0.0.1 : first extracts from RAAIN

package/drawers/CartesianDrawer.d.ts

@@ -0,0 +1,26 @@
+import { LatLng, Point } from 'leaflet';
+import { CartesianMapValue } from '../tools/CartesianMapValue';
+import { CartesianGridValue } from './CartesianGridValue';
+import { CartesianDrawerOptimization } from './CartesianDrawerOptimization';
+export declare class CartesianDrawer {
+    private cartesianMap2Points;
+    private cartesianMap2Display;
+    private cartesianMapZoom;
+    private type;
+    private geoValues;
+    private version;
+    private optimizations;
+    private distanceRatio;
+    private centerPoint;
+    constructor(cartesianMap2Points: (mapValue: CartesianMapValue) => {
+        p1: Point;
+        p2: Point;
+    }, cartesianMap2Display: (mapValue: CartesianMapValue) => boolean, cartesianMapZoom: () => number, type: string);
+    getVersion(): string;
+    setConfiguration(theme: number, range: number, optimizations: CartesianDrawerOptimization[]): void;
+    getOptimization(): CartesianDrawerOptimization;
+    updateValues(geoValues: CartesianMapValue[], version: string): void;
+    hasChanged(center: LatLng, centerPoint: Point): boolean;
+    renderCartesianMapValues(center: LatLng, centerPoint: Point, drawShape: (gridValue: CartesianGridValue) => boolean): number;
+    private getDistanceRatio;
+}

package/drawers/CartesianDrawer.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesianDrawer = void 0;
+const leaflet_1 = require("leaflet");
+const CartesianGridValue_1 = require("./CartesianGridValue");
+const MapTools_1 = require("../tools/MapTools");
+const CartesianDrawerOptimization_1 = require("./CartesianDrawerOptimization");
+class CartesianDrawer {
+    constructor(cartesianMap2Points, cartesianMap2Display, cartesianMapZoom, type) {
+        this.cartesianMap2Points = cartesianMap2Points;
+        this.cartesianMap2Display = cartesianMap2Display;
+        this.cartesianMapZoom = cartesianMapZoom;
+        this.type = type;
+        this.geoValues = [];
+        this.distanceRatio = 0;
+        this.centerPoint = new leaflet_1.Point(0, 0);
+        this.optimizations = CartesianDrawerOptimization_1.CartesianDrawerOptimization.Defaults();
+    }
+    getVersion() {
+        return this.version;
+    }
+    setConfiguration(theme, range, optimizations) {
+        this.optimizations = optimizations;
+    }
+    getOptimization() {
+        const optimizations = this.optimizations.filter((o) => {
+            return this.type.toLowerCase().indexOf(o.type.toLowerCase()) > 0;
+        });
+        if (optimizations.length === 1) {
+            return optimizations[0];
+        }
+        console.warn('no optimization found for cartesian drawer - please consider to use one');
+        return CartesianDrawerOptimization_1.CartesianDrawerOptimization.Defaults()[0];
+    }
+    updateValues(geoValues, version) {
+        console.log('updateValues', version);
+        this.geoValues = geoValues;
+        this.version = version;
+    }
+    hasChanged(center, centerPoint) {
+        if (!centerPoint.equals(this.centerPoint)) {
+            return true;
+        }
+        return this.distanceRatio !== this.getDistanceRatio(center);
+    }
+    renderCartesianMapValues(center, centerPoint, drawShape) {
+        let done = 0;
+        const distanceRatio = this.getDistanceRatio(center);
+        this.distanceRatio = distanceRatio;
+        this.centerPoint = centerPoint;
+        const optimization = this.getOptimization();
+        const filteredValues = optimization.filteringValues(this.cartesianMapZoom(), this.geoValues, this.cartesianMap2Display);
+        for (const mapValue of filteredValues) {
+            if (done > optimization.hardLimit) {
+                console.log('hard limit reached ', optimization === null || optimization === void 0 ? void 0 : optimization.hardLimit);
+                break;
+            }
+            const points = this.cartesianMap2Points(mapValue);
+            const gridValue = CartesianGridValue_1.CartesianGridValue.Create(mapValue, points, centerPoint, distanceRatio, optimization);
+            if (drawShape(gridValue)) {
+                done++;
+            }
+        }
+        return done;
+    }
+    getDistanceRatio(centerPoint) {
+        const distanceRatio = MapTools_1.MapTools.getCartesianDistanceRatio(centerPoint, this.geoValues, this.cartesianMap2Points);
+        // console.log('distanceRatio: ', distanceRatio);
+        return distanceRatio;
+    }
+}
+exports.CartesianDrawer = CartesianDrawer;
+//# sourceMappingURL=data:application/json;base64,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

package/drawers/CartesianDrawerOptimization.d.ts

@@ -0,0 +1,10 @@
+import { CartesianMapValue } from '../tools/CartesianMapValue';
+export declare class CartesianDrawerOptimization {
+    type: string;
+    hardLimit: number;
+    bypass: boolean;
+    considerZoom: boolean;
+    constructor(type: string, hardLimit: number, bypass: boolean, considerZoom: boolean);
+    static Defaults(): CartesianDrawerOptimization[];
+    filteringValues(zoom: number, geoValues: CartesianMapValue[], cartesianMap2Display: (mapValue: CartesianMapValue) => boolean): CartesianMapValue[];
+}

package/drawers/CartesianDrawerOptimization.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesianDrawerOptimization = void 0;
+class CartesianDrawerOptimization {
+    constructor(type, hardLimit, bypass, considerZoom) {
+        this.type = type;
+        this.hardLimit = hardLimit;
+        this.bypass = bypass;
+        this.considerZoom = considerZoom;
+    }
+    static Defaults() {
+        return [
+            new CartesianDrawerOptimization('default', 60000, false, false),
+            new CartesianDrawerOptimization('radar', 60000, true, true),
+            new CartesianDrawerOptimization('rain', 60000, false, false),
+            new CartesianDrawerOptimization('zoom', 60000, false, true),
+        ];
+    }
+    filteringValues(zoom, geoValues, cartesianMap2Display) {
+        let valuesToDisplay = geoValues.filter(v => v.value > 0.4);
+        if (cartesianMap2Display) {
+            valuesToDisplay = valuesToDisplay.filter(cartesianMap2Display);
+        }
+        if (this.considerZoom) {
+            const zoomLimit = 8;
+            if (zoom < zoomLimit) {
+                const each = zoomLimit + 1 - zoom;
+                let count = 0;
+                valuesToDisplay = valuesToDisplay.filter(v => {
+                    if (++count >= each) {
+                        count = 0;
+                        return true;
+                    }
+                    return false;
+                });
+            }
+        }
+        return valuesToDisplay;
+    }
+}
+exports.CartesianDrawerOptimization = CartesianDrawerOptimization;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FydGVzaWFuRHJhd2VyT3B0aW1pemF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RyYXdlcnMvQ2FydGVzaWFuRHJhd2VyT3B0aW1pemF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLE1BQWEsMkJBQTJCO0lBQ3BDLFlBQW1CLElBQVksRUFDWixTQUFpQixFQUNqQixNQUFlLEVBQ2YsWUFBcUI7UUFIckIsU0FBSSxHQUFKLElBQUksQ0FBUTtRQUNaLGNBQVMsR0FBVCxTQUFTLENBQVE7UUFDakIsV0FBTSxHQUFOLE1BQU0sQ0FBUztRQUNmLGlCQUFZLEdBQVosWUFBWSxDQUFTO0lBQ3hDLENBQUM7SUFHRCxNQUFNLENBQUMsUUFBUTtRQUNYLE9BQU87WUFDSCxJQUFJLDJCQUEyQixDQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQztZQUMvRCxJQUFJLDJCQUEyQixDQUFDLE9BQU8sRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQztZQUMzRCxJQUFJLDJCQUEyQixDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssQ0FBQztZQUM1RCxJQUFJLDJCQUEyQixDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQztTQUM5RCxDQUFDO0lBQ04sQ0FBQztJQUVELGVBQWUsQ0FBQyxJQUFZLEVBQ1osU0FBOEIsRUFDOUIsb0JBQThEO1FBRTFFLElBQUksZUFBZSxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsS0FBSyxHQUFHLEdBQUcsQ0FBQyxDQUFDO1FBQzNELElBQUksb0JBQW9CLEVBQUU7WUFDdEIsZUFBZSxHQUFHLGVBQWUsQ0FBQyxNQUFNLENBQUMsb0JBQW9CLENBQUMsQ0FBQztTQUNsRTtRQUNELElBQUksSUFBSSxDQUFDLFlBQVksRUFBRTtZQUNuQixNQUFNLFNBQVMsR0FBRyxDQUFDLENBQUM7WUFDcEIsSUFBSSxJQUFJLEdBQUcsU0FBUyxFQUFFO2dCQUNsQixNQUFNLElBQUksR0FBRyxTQUFTLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQztnQkFDbEMsSUFBSSxLQUFLLEdBQUcsQ0FBQyxDQUFDO2dCQUNkLGVBQWUsR0FBRyxlQUFlLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFO29CQUN6QyxJQUFJLEVBQUUsS0FBSyxJQUFJLElBQUksRUFBRTt3QkFDakIsS0FBSyxHQUFHLENBQUMsQ0FBQzt3QkFDVixPQUFPLElBQUksQ0FBQztxQkFDZjtvQkFDRCxPQUFPLEtBQUssQ0FBQztnQkFDakIsQ0FBQyxDQUFDLENBQUM7YUFDTjtTQUNKO1FBQ0QsT0FBTyxlQUFlLENBQUM7SUFDM0IsQ0FBQztDQUNKO0FBekNELGtFQXlDQyJ9

package/drawers/CartesianGridValue.d.ts

@@ -0,0 +1,15 @@
+import { CartesianMapValue } from '../tools/CartesianMapValue';
+import { Point } from 'leaflet';
+import { CartesianDrawerOptimization } from './CartesianDrawerOptimization';
+import { GridValue } from './GridValue';
+export declare class CartesianGridValue extends GridValue {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(color: number, transparency: number, x: number, y: number, width: number, height: number, id?: string);
+    static Create(src: CartesianMapValue, srcPoints: {
+        p1: Point;
+        p2: Point;
+    }, center: Point, ratio: number, optimization: CartesianDrawerOptimization): CartesianGridValue;
+}

package/drawers/CartesianGridValue.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartesianGridValue = void 0;
+const GridValue_1 = require("./GridValue");
+const MapTools_1 = require("../tools/MapTools");
+class CartesianGridValue extends GridValue_1.GridValue {
+    constructor(color, transparency, x, y, width, height, id) {
+        super(color, transparency, id);
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
+    static Create(src, srcPoints, center, ratio, optimization) {
+        let { transparency, value } = GridValue_1.GridValue.translateColor(src.value);
+        if ((optimization === null || optimization === void 0 ? void 0 : optimization.bypass) && 0.2 <= src.value) {
+            value = '#000000';
+            transparency = 0.6;
+        }
+        const x = srcPoints.p1.x, y = srcPoints.p1.y, width = srcPoints.p2.x - srcPoints.p1.x, height = srcPoints.p2.y - srcPoints.p1.y;
+        return new CartesianGridValue(MapTools_1.MapTools.hexStringToNumber(value), transparency, x, y, width, height, '' + Math.round(src.value * 100) / 100);
+    }
+}
+exports.CartesianGridValue = CartesianGridValue;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FydGVzaWFuR3JpZFZhbHVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RyYXdlcnMvQ2FydGVzaWFuR3JpZFZhbHVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUdBLDJDQUFzQztBQUN0QyxnREFBMkM7QUFFM0MsTUFBYSxrQkFBbUIsU0FBUSxxQkFBUztJQUU3QyxZQUNJLEtBQWEsRUFDYixZQUFvQixFQUNiLENBQVMsRUFDVCxDQUFTLEVBQ1QsS0FBYSxFQUNiLE1BQWMsRUFDckIsRUFBVztRQUNYLEtBQUssQ0FBQyxLQUFLLEVBQUUsWUFBWSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBTHhCLE1BQUMsR0FBRCxDQUFDLENBQVE7UUFDVCxNQUFDLEdBQUQsQ0FBQyxDQUFRO1FBQ1QsVUFBSyxHQUFMLEtBQUssQ0FBUTtRQUNiLFdBQU0sR0FBTixNQUFNLENBQVE7SUFHekIsQ0FBQztJQUVELE1BQU0sQ0FBQyxNQUFNLENBQUMsR0FBc0IsRUFDdEIsU0FBbUMsRUFDbkMsTUFBYSxFQUNiLEtBQWEsRUFDYixZQUF5QztRQUVuRCxJQUFJLEVBQUMsWUFBWSxFQUFFLEtBQUssRUFBQyxHQUFHLHFCQUFTLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUVoRSxJQUFJLENBQUEsWUFBWSxhQUFaLFlBQVksdUJBQVosWUFBWSxDQUFFLE1BQU0sS0FBSSxHQUFHLElBQUksR0FBRyxDQUFDLEtBQUssRUFBRTtZQUMxQyxLQUFLLEdBQUcsU0FBUyxDQUFDO1lBQ2xCLFlBQVksR0FBRyxHQUFHLENBQUM7U0FDdEI7UUFFRCxNQUFNLENBQUMsR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsRUFDcEIsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUNsQixLQUFLLEdBQUcsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQ3ZDLE1BQU0sR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztRQUU3QyxPQUFPLElBQUksa0JBQWtCLENBQ3pCLG1CQUFRLENBQUMsaUJBQWlCLENBQUMsS0FBSyxDQUFDLEVBQ2pDLFlBQVksRUFDWixDQUFDLEVBQ0QsQ0FBQyxFQUNELEtBQUssRUFDTCxNQUFNLEVBQ04sRUFBRSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEtBQUssR0FBRyxHQUFHLENBQUMsR0FBRyxHQUFHLENBQ3pDLENBQUM7SUFDTixDQUFDO0NBRUo7QUExQ0QsZ0RBMENDIn0=

package/drawers/GridValue.d.ts

@@ -0,0 +1,12 @@
+export declare class GridValue {
+    private color;
+    private transparency;
+    id?: string;
+    constructor(color: number, transparency: number, id?: string);
+    protected static translateColor(srcValue: any): {
+        value: string;
+        transparency: number;
+    };
+    getColor(forcedColor?: number): number;
+    getTransparency(forcedOpacity?: number): number;
+}

package/drawers/GridValue.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GridValue = void 0;
+class GridValue {
+    constructor(color, transparency, id) {
+        this.color = color;
+        this.transparency = transparency;
+        this.id = id;
+    }
+    static translateColor(srcValue) {
+        let value = '#000000';
+        let transparency = 1; // 1 => invisible
+        if (0 < srcValue && srcValue < 0.4) {
+            value = '#000e98';
+            transparency = 0.9;
+        }
+        else if (srcValue < 1) {
+            value = '#0013C0';
+            transparency = 0.7;
+        }
+        else if (srcValue < 3) {
+            value = '#00CEF9';
+            transparency = 0.65;
+        }
+        else if (srcValue < 10) {
+            value = '#009A0F';
+            transparency = 0.6;
+        }
+        else if (srcValue < 20) {
+            value = '#6DED00';
+            transparency = 0.55;
+        }
+        else if (srcValue < 30) {
+            value = '#FFF300';
+            transparency = 0.50;
+        }
+        else if (srcValue < 50) {
+            value = '#aa72f3';
+            transparency = 0.45;
+        }
+        else if (srcValue < 100) {
+            value = '#f67bec';
+            transparency = 0.4;
+        }
+        else if (srcValue < 150) {
+            value = '#ff23cd';
+            transparency = 0.3;
+        }
+        else if (srcValue < 200) {
+            value = '#ff0707';
+            transparency = 0.3;
+        }
+        else if (srcValue < 250) {
+            value = '#c2042f';
+            transparency = 0.3;
+        }
+        else if (srcValue < 300) {
+            value = '#7e0321';
+            transparency = 0.3;
+        }
+        else if (300 <= srcValue) {
+            value = '#000000';
+            transparency = 0.3;
+        }
+        return { value, transparency };
+    }
+    getColor(forcedColor) {
+        return forcedColor ? forcedColor : this.color;
+    }
+    getTransparency(forcedOpacity) {
+        return forcedOpacity ? forcedOpacity : this.transparency;
+    }
+}
+exports.GridValue = GridValue;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JpZFZhbHVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RyYXdlcnMvR3JpZFZhbHVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLE1BQWEsU0FBUztJQUVsQixZQUNZLEtBQWEsRUFDYixZQUFvQixFQUNyQixFQUFXO1FBRlYsVUFBSyxHQUFMLEtBQUssQ0FBUTtRQUNiLGlCQUFZLEdBQVosWUFBWSxDQUFRO1FBQ3JCLE9BQUUsR0FBRixFQUFFLENBQVM7SUFDdEIsQ0FBQztJQUVTLE1BQU0sQ0FBQyxjQUFjLENBQUMsUUFBUTtRQUVwQyxJQUFJLEtBQUssR0FBRyxTQUFTLENBQUM7UUFDdEIsSUFBSSxZQUFZLEdBQUcsQ0FBQyxDQUFDLENBQUMsaUJBQWlCO1FBRXZDLElBQUksQ0FBQyxHQUFHLFFBQVEsSUFBSSxRQUFRLEdBQUcsR0FBRyxFQUFFO1lBQ2hDLEtBQUssR0FBRyxTQUFTLENBQUM7WUFDbEIsWUFBWSxHQUFHLEdBQUcsQ0FBQztTQUN0QjthQUFNLElBQUksUUFBUSxHQUFHLENBQUMsRUFBRTtZQUNyQixLQUFLLEdBQUcsU0FBUyxDQUFDO1lBQ2xCLFlBQVksR0FBRyxHQUFHLENBQUM7U0FDdEI7YUFBTSxJQUFJLFFBQVEsR0FBRyxDQUFDLEVBQUU7WUFDckIsS0FBSyxHQUFHLFNBQVMsQ0FBQztZQUNsQixZQUFZLEdBQUcsSUFBSSxDQUFDO1NBQ3ZCO2FBQU0sSUFBSSxRQUFRLEdBQUcsRUFBRSxFQUFFO1lBQ3RCLEtBQUssR0FBRyxTQUFTLENBQUM7WUFDbEIsWUFBWSxHQUFHLEdBQUcsQ0FBQztTQUN0QjthQUFNLElBQUksUUFBUSxHQUFHLEVBQUUsRUFBRTtZQUN0QixLQUFLLEdBQUcsU0FBUyxDQUFDO1lBQ2xCLFlBQVksR0FBRyxJQUFJLENBQUM7U0FDdkI7YUFBTSxJQUFJLFFBQVEsR0FBRyxFQUFFLEVBQUU7WUFDdEIsS0FBSyxHQUFHLFNBQVMsQ0FBQztZQUNsQixZQUFZLEdBQUcsSUFBSSxDQUFDO1NBQ3ZCO2FBQU0sSUFBSSxRQUFRLEdBQUcsRUFBRSxFQUFFO1lBQ3RCLEtBQUssR0FBRyxTQUFTLENBQUM7WUFDbEIsWUFBWSxHQUFHLElBQUksQ0FBQztTQUN2QjthQUFNLElBQUksUUFBUSxHQUFHLEdBQUcsRUFBRTtZQUN2QixLQUFLLEdBQUcsU0FBUyxDQUFDO1lBQ2xCLFlBQVksR0FBRyxHQUFHLENBQUM7U0FDdEI7YUFBTSxJQUFJLFFBQVEsR0FBRyxHQUFHLEVBQUU7WUFDdkIsS0FBSyxHQUFHLFNBQVMsQ0FBQztZQUNsQixZQUFZLEdBQUcsR0FBRyxDQUFDO1NBQ3RCO2FBQU0sSUFBSSxRQUFRLEdBQUcsR0FBRyxFQUFFO1lBQ3ZCLEtBQUssR0FBRyxTQUFTLENBQUM7WUFDbEIsWUFBWSxHQUFHLEdBQUcsQ0FBQztTQUN0QjthQUFNLElBQUksUUFBUSxHQUFHLEdBQUcsRUFBRTtZQUN2QixLQUFLLEdBQUcsU0FBUyxDQUFDO1lBQ2xCLFlBQVksR0FBRyxHQUFHLENBQUM7U0FDdEI7YUFBTSxJQUFJLFFBQVEsR0FBRyxHQUFHLEVBQUU7WUFDdkIsS0FBSyxHQUFHLFNBQVMsQ0FBQztZQUNsQixZQUFZLEdBQUcsR0FBRyxDQUFDO1NBQ3RCO2FBQU0sSUFBSSxHQUFHLElBQUksUUFBUSxFQUFFO1lBQ3hCLEtBQUssR0FBRyxTQUFTLENBQUM7WUFDbEIsWUFBWSxHQUFHLEdBQUcsQ0FBQztTQUN0QjtRQUVELE9BQU8sRUFBQyxLQUFLLEVBQUUsWUFBWSxFQUFDLENBQUM7SUFDakMsQ0FBQztJQUVNLFFBQVEsQ0FBQyxXQUFvQjtRQUNoQyxPQUFPLFdBQVcsQ0FBQyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ2xELENBQUM7SUFFTSxlQUFlLENBQUMsYUFBc0I7UUFDekMsT0FBTyxhQUFhLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQztJQUM3RCxDQUFDO0NBRUo7QUFqRUQsOEJBaUVDIn0=

package/drawers/PolarDrawer.d.ts

@@ -0,0 +1,28 @@
+import { LatLng, Point } from 'leaflet';
+import { PolarGridValue } from './PolarGridValue';
+import { PolarMapValue } from '../tools/PolarMapValue';
+import { PolarDrawerOptimization } from './PolarDrawerOptimization';
+export declare class PolarDrawer {
+    private polarMap2Point;
+    private polarMap2Display;
+    private polarMapZoom;
+    private type;
+    private geoValues;
+    private version;
+    private optimizations;
+    private possibleDrawing;
+    private distanceRatio;
+    private centerPoint;
+    constructor(polarMap2Point: (pv: PolarMapValue) => Point, polarMap2Display: (pv: PolarMapValue) => boolean, polarMapZoom: () => number, type: string);
+    getVersion(): string;
+    setConfiguration(theme: number, range: number, optimizations: PolarDrawerOptimization[]): void;
+    getOptimization(): PolarDrawerOptimization;
+    updateValues(geoValues: PolarMapValue[], version: string): void;
+    hasChanged(center: LatLng, centerPoint: Point): boolean;
+    renderPolarMapValues(center: LatLng, centerPoint: Point, drawPolarSharp: (polar1: PolarGridValue, polar2?: PolarGridValue) => boolean): number;
+    _getNextOffset(index: any, edgeCount: any): number;
+    protected getPossibleDrawing(): number;
+    private getDistanceRatio;
+    private getAzimuthStepInDegrees;
+    private getEdgeCount;
+}

package/drawers/PolarDrawer.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarDrawer = void 0;
+const leaflet_1 = require("leaflet");
+const PolarGridValue_1 = require("./PolarGridValue");
+const PolarMapValue_1 = require("../tools/PolarMapValue");
+const PolarDrawerOptimization_1 = require("./PolarDrawerOptimization");
+const MapTools_1 = require("../tools/MapTools");
+class PolarDrawer {
+    constructor(polarMap2Point, polarMap2Display, polarMapZoom, type) {
+        this.polarMap2Point = polarMap2Point;
+        this.polarMap2Display = polarMap2Display;
+        this.polarMapZoom = polarMapZoom;
+        this.type = type;
+        this.geoValues = [];
+        this.possibleDrawing = 0;
+        this.distanceRatio = 0;
+        this.centerPoint = new leaflet_1.Point(0, 0);
+        this.optimizations = PolarDrawerOptimization_1.PolarDrawerOptimization.Defaults();
+    }
+    getVersion() {
+        return this.version;
+    }
+    setConfiguration(theme, range, optimizations) {
+        this.optimizations = optimizations;
+    }
+    getOptimization() {
+        const optimizations = this.optimizations.filter((o) => {
+            return this.type.toLowerCase().indexOf(o.type.toLowerCase()) > 0;
+        });
+        if (optimizations.length === 1) {
+            return optimizations[0];
+        }
+        console.warn('no optimization found for polar drawer - please consider to use one');
+        return PolarDrawerOptimization_1.PolarDrawerOptimization.Defaults()[0];
+    }
+    updateValues(geoValues, version) {
+        console.log('updateValues', version);
+        this.geoValues = geoValues;
+        this.version = version;
+    }
+    hasChanged(center, centerPoint) {
+        if (!centerPoint.equals(this.centerPoint)) {
+            return true;
+        }
+        if (this.distanceRatio !== this.getDistanceRatio(centerPoint)) {
+            return true;
+        }
+        return this.possibleDrawing !== this.getPossibleDrawing();
+    }
+    renderPolarMapValues(center, centerPoint, drawPolarSharp) {
+        let done = 0;
+        const edgeCount = this.getEdgeCount();
+        const distanceRatio = this.getDistanceRatio(centerPoint);
+        const azimuthStepInDegrees = this.getAzimuthStepInDegrees();
+        const optimizationValues = {
+            x1: null,
+            x2: null
+        };
+        if (distanceRatio <= 0) {
+            console.warn('distanceRatio is 0 - no sense ? ', center, centerPoint);
+            return 0;
+        }
+        const optimization = this.getOptimization();
+        this.possibleDrawing = this.getPossibleDrawing();
+        this.distanceRatio = distanceRatio;
+        this.centerPoint = centerPoint;
+        const filteredValues = optimization.filteringValues(this.polarMapZoom(), this.geoValues, this.polarMap2Display);
+        for (let [i, polarValue] of filteredValues.entries()) {
+            if (done > optimization.hardLimit) {
+                console.log('hard limit reached ', optimization.hardLimit);
+                break;
+            }
+            polarValue = PolarMapValue_1.PolarMapValue.Duplicate(polarValue);
+            polarValue.setCenter({ latitude: center.lat, longitude: center.lng });
+            // console.log('rendered polarValue : ', polarValue);
+            if (optimization.groupAzimuths()) {
+                const drawValue = (x1, pv2, forceDraw) => {
+                    if (!x1 || !pv2) {
+                        return false;
+                    }
+                    const x2 = PolarGridValue_1.PolarGridValue.Create(pv2, distanceRatio, optimization);
+                    x2.polarAzimuthInDegrees = x1.polarAzimuthInDegrees + azimuthStepInDegrees;
+                    let drawDone = false;
+                    if (!forceDraw && x2.getTransparency() === x1.getTransparency()) {
+                        // same value => optimize drawing
+                        optimizationValues.x2 = x2;
+                    }
+                    else {
+                        if (x1.getTransparency() < 1) {
+                            drawDone = drawPolarSharp(x1, x2);
+                        }
+                        else {
+                            drawDone = true;
+                        }
+                        optimizationValues.x2 = null;
+                        if (drawDone) {
+                            done++;
+                        }
+                    }
+                    return drawDone;
+                };
+                if (!this.polarMap2Display(polarValue)) {
+                    drawValue(optimizationValues.x1, polarValue, true);
+                    optimizationValues.x1 = null;
+                }
+                else if (((i % edgeCount) === (edgeCount - 1))) {
+                    drawValue(optimizationValues.x1, polarValue, true);
+                    optimizationValues.x1 = null;
+                    i = this._getNextOffset(i, edgeCount) - 1;
+                }
+                else {
+                    const drawDone = drawValue(optimizationValues.x1, polarValue);
+                    if (drawDone || !optimizationValues.x1) {
+                        optimizationValues.x1 = PolarGridValue_1.PolarGridValue.Create(polarValue, distanceRatio, optimization);
+                    }
+                }
+            }
+            else {
+                const x = PolarGridValue_1.PolarGridValue.Create(polarValue, distanceRatio, optimization);
+                done += drawPolarSharp(x) ? 1 : 0;
+            }
+        }
+        console.log('Polar done vs possible:', done, this.possibleDrawing);
+        return done;
+    }
+    _getNextOffset(index, edgeCount) {
+        const preciseId = (index + 1) / edgeCount;
+        const edgeId = Math.floor(preciseId);
+        let newIndex = (edgeId + 1) * edgeCount;
+        if (preciseId === edgeId) {
+            newIndex = edgeId * edgeCount;
+        }
+        return newIndex;
+    }
+    getPossibleDrawing() {
+        let count = 0;
+        const nonNullValues = this.geoValues.filter(v => v.value);
+        for (const mapValue of nonNullValues) {
+            if (this.polarMap2Display(mapValue)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    getDistanceRatio(centerPoint) {
+        if (this.geoValues.length < 1) {
+            return 0;
+        }
+        const distanceRatio = MapTools_1.MapTools.getPolarDistanceRatio(centerPoint, this.geoValues[this.geoValues.length - 1], this.polarMap2Point);
+        // console.log('distanceRatio: ', distanceRatio);
+        return distanceRatio;
+    }
+    getAzimuthStepInDegrees() {
+        if (this.geoValues.length <= 1) {
+            return 360;
+        }
+        const firstGeoValue = this.geoValues[0];
+        let azimuthDiff = 360;
+        const sameAzimuth = firstGeoValue.polarAzimuthInDegrees;
+        for (const polarValue of this.geoValues) {
+            if (sameAzimuth !== polarValue.polarAzimuthInDegrees) {
+                azimuthDiff = polarValue.polarAzimuthInDegrees - sameAzimuth;
+                break;
+            }
+        }
+        // console.log('azimuthStepInDegrees: ', azimuthDiff);
+        return azimuthDiff;
+    }
+    getEdgeCount() {
+        if (this.geoValues.length <= 1) {
+            return 1;
+        }
+        let sameEdgeValuesCount = 0;
+        const firstGeoValue = this.geoValues[0];
+        for (const polarValue of this.geoValues) {
+            if (firstGeoValue.polarAzimuthInDegrees !== polarValue.polarAzimuthInDegrees) {
+                break;
+            }
+            sameEdgeValuesCount++;
+        }
+        // console.log('sameEdgeValuesCount: ', sameEdgeValuesCount);
+        return sameEdgeValuesCount;
+    }
+}
+exports.PolarDrawer = PolarDrawer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PolarDrawer.js","sourceRoot":"","sources":["../../src/drawers/PolarDrawer.ts"],"names":[],"mappings":"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"}

package/drawers/PolarDrawerOptimization.d.ts

@@ -0,0 +1,14 @@
+import { PolarMapValue } from '../tools/PolarMapValue';
+export declare class PolarDrawerOptimization {
+    type: string;
+    hardLimit: number;
+    min: number;
+    max: number;
+    step: number;
+    bypass: boolean;
+    considerZoom: boolean;
+    constructor(type: string, hardLimit: number, min: number, max: number, step: number, bypass: boolean, considerZoom: boolean);
+    static Defaults(): PolarDrawerOptimization[];
+    filteringValues(zoom: number, geoValues: PolarMapValue[], polarMap2Display: (mapValue: PolarMapValue) => boolean): PolarMapValue[];
+    groupAzimuths(): boolean;
+}

package/drawers/PolarDrawerOptimization.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolarDrawerOptimization = void 0;
+class PolarDrawerOptimization {
+    constructor(type, hardLimit, min, max, step, bypass, considerZoom) {
+        this.type = type;
+        this.hardLimit = hardLimit;
+        this.min = min;
+        this.max = max;
+        this.step = step;
+        this.bypass = bypass;
+        this.considerZoom = considerZoom;
+    }
+    static Defaults() {
+        return [
+            new PolarDrawerOptimization('default', 40001, 0, 100, 10, false, false),
+            new PolarDrawerOptimization('radar', 40002, 0.2, 100, 5, true, true),
+            new PolarDrawerOptimization('rain', 40003, 0, 76, 10, false, true),
+            new PolarDrawerOptimization('zoom', 40003, 0, 76, 10, false, true),
+        ];
+    }
+    filteringValues(zoom, geoValues, polarMap2Display) {
+        // non null values
+        let valuesToDisplay = geoValues.filter(v => v.value > 0);
+        // into the map
+        if (polarMap2Display) {
+            valuesToDisplay = valuesToDisplay.filter(polarMap2Display);
+        }
+        // reduced in case of zoom
+        if (this.considerZoom) {
+            const zoomLimit = 10;
+            if (zoom < zoomLimit) {
+                const each = zoomLimit + 1 - zoom;
+                let count = 0;
+                valuesToDisplay = valuesToDisplay.filter(v => {
+                    if (++count >= each) {
+                        count = 0;
+                        return true;
+                    }
+                    return false;
+                });
+            }
+        }
+        return valuesToDisplay;
+    }
+    groupAzimuths() {
+        if (this.type === '???') {
+            return true;
+        }
+        return false;
+    }
+}
+exports.PolarDrawerOptimization = PolarDrawerOptimization;
+//# sourceMappingURL=data:application/json;base64,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

package/drawers/PolarGridValue.d.ts

@@ -0,0 +1,13 @@
+import { PolarMapValue } from '../tools/PolarMapValue';
+import { PolarDrawerOptimization } from './PolarDrawerOptimization';
+import { Point } from 'leaflet';
+import { GridValue } from './GridValue';
+export declare class PolarGridValue extends GridValue {
+    polarAzimuthInDegrees: number;
+    private polarDistanceRelative;
+    constructor(color: number, transparency: number, polarAzimuthInDegrees: number, polarDistanceRelative: number, id?: string);
+    static Create(src: PolarMapValue, distanceRatio: number, optimization: PolarDrawerOptimization): PolarGridValue;
+    getPolarDistanceRelative(): number;
+    setPolarDistanceRelative(d: number): void;
+    getPositionFrom(centerPoint: Point): Point;
+}