raain-model 2.6.7 → 2.6.10

package/{rain/RainComputationAbstract.js → src/rain/RainComputationAbstract.ts}

@@ -1,18 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RainComputationAbstract = void 0;
-const organization_1 = require("../organization");
-const radar_1 = require("../radar");
-const RainNode_1 = require("./RainNode");
-const cartesian_1 = require("../cartesian");
-const RainMeasure_1 = require("./RainMeasure");
-const MergeStrategy_1 = require("./MergeStrategy");
+import {Link, RaainNode} from '../organization';
+import {RadarMeasure, RadarNode} from '../radar';
+import {RainNode} from './RainNode';
+import {CartesianMeasureValue, CartesianTools, CartesianValue, LatLng, RainCartesianMeasureValue} from '../cartesian';
+import {RainMeasure} from './RainMeasure';
+import {MergeLatLng, MergeStrategy} from './MergeStrategy';
+
 /**
  *  not used directly
  */
-class RainComputationAbstract extends organization_1.RaainNode {
-    constructor(json) {
+export class RainComputationAbstract extends RaainNode {
+
+    public quality: number;
+    public progressIngest: number;
+    public progressComputing: number;
+    public timeSpentInMs: number;
+    public date: Date;
+    public isReady: boolean;
+    public isDoneDate: Date;
+    public launchedBy: string;
+    public name: string;
+
+    protected mergeTools: {
+        cartesianTools: CartesianTools;
+        latsLngs: MergeLatLng[][];
+        limitPoints: LatLng[];
+    };
+
+    constructor(json: {
+        id: string,
+        date: Date,
+        isReady: boolean,
+
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: Link | RaainNode,
+        radars?: Link[] | RaainNode[],
+
+    }) {
         super(json);
+
         this.date = json.date ? new Date(json.date) : null;
         this.quality = json.quality >= 0 ? json.quality : -1;
         this.progressIngest = json.progressIngest >= 0 ? json.progressIngest : -1;
@@ -21,58 +53,61 @@ class RainComputationAbstract extends organization_1.RaainNode {
         this.isReady = !!json.isReady;
         this.isDoneDate = json.isDoneDate ? new Date(json.isDoneDate) : undefined;
         this.launchedBy = json.launchedBy;
+
         this.replaceRainLink(json.links);
         this.replaceRainLink(json.rain);
         this.addRadarLinks(json.links);
         this.addRadarLinks(json.radars);
     }
-    static _getRadarLinks(linksToPurify) {
+
+    private static _getRadarLinks(linksToPurify: any[]): any[] {
         if (!linksToPurify || linksToPurify.length === 0) {
             return [];
         }
+
         return linksToPurify.map(l => {
-            if (l instanceof organization_1.Link) {
+            if (l instanceof Link) {
                 return l;
-            }
-            else if (l && l['_id']) {
-                return new radar_1.RadarNode({ id: l['_id'].toString(), latitude: 0, longitude: 0, name: l.name, team: l.team });
-            }
-            else if (l && l.id) {
-                return new radar_1.RadarNode({
-                    id: l.id.toString(), // 'hex'
+            } else if (l && l['_id']) {
+                return new RadarNode({id: l['_id'].toString(), latitude: 0, longitude: 0, name: l.name, team: l.team});
+            } else if (l && l.id) {
+                return new RadarNode({
+                    id: l.id.toString(),// 'hex'
                     latitude: 0, longitude: 0, name: l.name, team: l.team
                 });
             }
         });
     }
-    static _getRadarMeasureLinks(linksToPurify) {
+
+    private static _getRadarMeasureLinks(linksToPurify: any[]): any[] {
         if (!linksToPurify || linksToPurify.length === 0) {
             return [];
         }
+
         return linksToPurify.map(l => {
-            if (l instanceof organization_1.Link) {
+            if (l instanceof Link) {
                 return l;
-            }
-            else if (l && l['_id']) {
-                return new radar_1.RadarMeasure({ id: l['_id'].toString(), values: [] });
-            }
-            else if (l && l.id) {
-                return new radar_1.RadarMeasure({ id: l.id.toString(), values: [] }); // 'hex'
+            } else if (l && l['_id']) {
+                return new RadarMeasure({id: l['_id'].toString(), values: []});
+            } else if (l && l.id) {
+                return new RadarMeasure({id: l.id.toString(), values: []}); // 'hex'
             }
         });
     }
-    static _getRainLink(linkToPurify) {
+
+    private static _getRainLink(linkToPurify: RaainNode): RainNode {
         if (!linkToPurify || !linkToPurify.id) {
             return null;
         }
-        return new RainNode_1.RainNode({
+
+        return new RainNode({
             id: linkToPurify.id.toString(),
             name: linkToPurify.id.toString(),
             team: null
         });
     }
-    toJSON() {
-        var _a;
+
+    public toJSON(): any {
         const json = super.toJSON();
         json['date'] = this.date.toISOString();
         json['quality'] = this.quality;
@@ -80,72 +115,91 @@ class RainComputationAbstract extends organization_1.RaainNode {
         json['progressComputing'] = this.progressComputing;
         json['timeSpentInMs'] = this.timeSpentInMs;
         json['isReady'] = this.isReady;
-        json['isDoneDate'] = (_a = this.isDoneDate) === null || _a === void 0 ? void 0 : _a.toISOString();
+        json['isDoneDate'] = this.isDoneDate?.toISOString();
         json['launchedBy'] = this.launchedBy;
         json['name'] = this.name;
         return json;
     }
-    addRadarLinks(linksToAdd) {
+
+    public addRadarLinks(linksToAdd: Link[] | RaainNode[]): void {
         this.addLinks(RainComputationAbstract._getRadarLinks(linksToAdd));
     }
-    replaceRainLink(linksToAdd) {
+
+    public replaceRainLink(linksToAdd: Link | RaainNode | any): void {
         this.addLinks([RainComputationAbstract._getRainLink(linksToAdd)]);
     }
-    addRadarMeasureLinks(linksToAdd) {
+
+    public addRadarMeasureLinks(linksToAdd: Link[] | any[]): void {
         this.addLinks(RainComputationAbstract._getRadarMeasureLinks(linksToAdd));
     }
-    getBuiltMergeTools(rainMeasures, options) {
+
+    public getBuiltMergeTools(rainMeasures: RainMeasure[], options: {
+        cartesianTools: CartesianTools,
+        mergeLimitPoints: LatLng[]
+    }) {
         this.buildLatLngMatrix(options);
         this.buildMergeTools(rainMeasures);
         return this.mergeTools;
     }
-    getMergeLatLngIndex(cartesianValue) {
+
+    public getMergeLatLngIndex(cartesianValue: CartesianValue) {
+
         const latLng = this.mergeTools.cartesianTools.getLatLngFromEarthMap(cartesianValue);
         const latLngScale = this.mergeTools.cartesianTools.getScaleLatLngFromEarth(latLng);
+
         const latIndex = Math.round((latLng.lat - this.mergeTools.limitPoints[0].lat) / latLngScale.lat);
         const lngIndex = Math.round((latLng.lng - this.mergeTools.limitPoints[0].lng) / latLngScale.lng);
-        return { index: [latIndex, lngIndex], latLng };
+
+        return {index: [latIndex, lngIndex], latLng};
     }
-    buildLatLngMatrix(options) {
-        const latsLngs = [];
-        this.mergeTools = { latsLngs, cartesianTools: options.cartesianTools, limitPoints: [] };
+
+    protected buildLatLngMatrix(options: {
+        cartesianTools: CartesianTools,
+        mergeLimitPoints: LatLng[]
+    }) {
+        const latsLngs: MergeLatLng[][] = [];
+        this.mergeTools = {latsLngs, cartesianTools: options.cartesianTools, limitPoints: []};
         if (!options.mergeLimitPoints) {
             return this.mergeTools;
         }
+
         const downPoint = options.cartesianTools.getLatLngFromEarthMap(options.mergeLimitPoints[0]);
         const topPoint = options.cartesianTools.getLatLngFromEarthMap(options.mergeLimitPoints[1]);
         const scaleLat = options.cartesianTools.getScaleLatLng(downPoint);
+
         for (let lat = downPoint.lat; lat <= topPoint.lat; lat += scaleLat.lat) {
-            lat = cartesian_1.CartesianTools.LimitWithPrecision(lat);
-            const latLng = new cartesian_1.LatLng({ lat, lng: downPoint.lng });
+            lat = CartesianTools.LimitWithPrecision(lat);
+            const latLng = new LatLng({lat, lng: downPoint.lng});
             const scaleLng = options.cartesianTools.getScaleLatLng(latLng);
             const lngCount = Math.round((topPoint.lng - downPoint.lng) / scaleLng.lng) + 1;
             const lngs = [];
             for (let i = 0; i < lngCount; i++) {
-                const initValue = { sum: 0, max: 0, count: 0, latLng: undefined };
+                const initValue: MergeLatLng = {sum: 0, max: 0, count: 0, latLng: undefined};
                 lngs.push(initValue);
             }
             latsLngs.push(lngs);
         }
-        this.mergeTools = { latsLngs, cartesianTools: options.cartesianTools, limitPoints: [downPoint, topPoint] };
+
+        this.mergeTools = {latsLngs, cartesianTools: options.cartesianTools, limitPoints: [downPoint, topPoint]};
         return this.mergeTools;
     }
-    buildMergeTools(rainMeasures) {
+
+    protected buildMergeTools(rainMeasures: RainMeasure[]) {
         for (const rainMeasure of rainMeasures) {
             for (const value of rainMeasure.values) {
                 if (typeof value['cartesianValues'] !== 'undefined') {
-                    const cartesianMeasureValue = new cartesian_1.CartesianMeasureValue(value);
+                    const cartesianMeasureValue = new CartesianMeasureValue(value as any);
                     const cartesianValues = cartesianMeasureValue.getCartesianValues();
                     for (const cartesianValue of cartesianValues) {
-                        const { index, latLng } = this.getMergeLatLngIndex(cartesianValue);
+                        const {index, latLng} = this.getMergeLatLngIndex(cartesianValue);
                         if (index[0] >= 0 && index[1] >= 0 && index[0] < this.mergeTools.latsLngs.length &&
                             index[1] < this.mergeTools.latsLngs[index[0]].length) {
-                            this.mergeTools.latsLngs[index[0]][index[1]].latLng = cartesian_1.CartesianTools.CreateLatLng(latLng);
+                            this.mergeTools.latsLngs[index[0]][index[1]].latLng = CartesianTools.CreateLatLng(latLng);
                             this.mergeTools.latsLngs[index[0]][index[1]].sum += cartesianValue.value;
-                            this.mergeTools.latsLngs[index[0]][index[1]].max = Math.max(cartesianValue.value, this.mergeTools.latsLngs[index[0]][index[1]].max);
+                            this.mergeTools.latsLngs[index[0]][index[1]].max = Math.max(
+                                cartesianValue.value, this.mergeTools.latsLngs[index[0]][index[1]].max);
                             this.mergeTools.latsLngs[index[0]][index[1]].count++;
-                        }
-                        else {
+                        } else {
                             // throw new Error(`Wrong mergeRainMeasure ${latLngIndex[0]} ${latLngIndex[1]}`);
                         }
                     }
@@ -153,44 +207,56 @@ class RainComputationAbstract extends organization_1.RaainNode {
             }
         }
     }
-    getLinkType() {
+
+    protected getLinkType(): string {
         throw Error('abstract');
     }
-    mergeRainMeasures(rainMeasures, options) {
+
+    protected mergeRainMeasures(rainMeasures: RainMeasure[],
+                                options: {
+                                    mergeStrategy: MergeStrategy,
+                                    mergeLimitPoints: [LatLng, LatLng],
+                                    removeNullValues?: boolean,
+                                }): RainMeasure[] {
+
         if (rainMeasures.length === 0) {
             return [];
         }
+
         this.buildMergeTools(rainMeasures);
+
         const firstCartesianRainMeasure = rainMeasures[0];
         const cartesianValuesMerged = this.buildMergeCartesianValues(options.mergeStrategy, options.removeNullValues);
-        const rm = new RainMeasure_1.RainMeasure(firstCartesianRainMeasure.toJSON());
-        rm.values = [new cartesian_1.RainCartesianMeasureValue({
-                cartesianValues: cartesianValuesMerged,
-                version: firstCartesianRainMeasure.getVersion(),
-                limitPoints: options.mergeLimitPoints,
-            })];
+
+        const rm = new RainMeasure(firstCartesianRainMeasure.toJSON());
+        rm.values = [new RainCartesianMeasureValue({
+            cartesianValues: cartesianValuesMerged,
+            version: firstCartesianRainMeasure.getVersion(),
+            limitPoints: options.mergeLimitPoints,
+        })];
+
         return [rm];
     }
-    buildMergeCartesianValues(mergeStrategy, removeNullValues = false) {
-        const cartesianValuesMerged = [];
+
+    protected buildMergeCartesianValues(mergeStrategy: MergeStrategy, removeNullValues = false) {
+        const cartesianValuesMerged: CartesianValue[] = [];
         for (const [latIndex, latValues] of this.mergeTools.latsLngs.entries()) {
             for (const [lngIndex, mergeValue] of latValues.entries()) {
                 let value = mergeValue.sum;
-                if (mergeStrategy === MergeStrategy_1.MergeStrategy.AVERAGE) {
+                if (mergeStrategy === MergeStrategy.AVERAGE) {
                     value = mergeValue.count ? value / mergeValue.count : -1;
-                }
-                else if (mergeStrategy === MergeStrategy_1.MergeStrategy.MAX) {
+                } else if (mergeStrategy === MergeStrategy.MAX) {
                     value = mergeValue.max;
                 }
+
                 if (mergeValue.count && !(removeNullValues && !value)) {
                     const lat = mergeValue.latLng.lat;
                     const lng = mergeValue.latLng.lng;
-                    cartesianValuesMerged.push(new cartesian_1.CartesianValue({ value, lat, lng }));
+                    cartesianValuesMerged.push(new CartesianValue({value, lat, lng}));
                 }
             }
         }
         return cartesianValuesMerged;
     }
+
 }
-exports.RainComputationAbstract = RainComputationAbstract;
-//# sourceMappingURL=RainComputationAbstract.js.map

package/src/rain/RainComputationMap.ts

@@ -0,0 +1,139 @@
+import {RainComputationAbstract} from './RainComputationAbstract';
+import {Link, RaainNode} from '../organization';
+import {RainMeasure} from './RainMeasure';
+import {CartesianTools, LatLng} from '../cartesian';
+import {MergeStrategy} from './MergeStrategy';
+
+/**
+ * Represents a map-based rain computation result.
+ * This class extends RainComputationAbstract to provide map-specific functionality for rain data processing.
+ * 
+ * @example
+ * ```typescript
+ * const computation = new RainComputationMap({
+ *   id: 'comp1',
+ *   date: new Date(),
+ *   isReady: true,
+ *   map: [] // Your rain measurement data here
+ * });
+ * ```
+ * 
+ * @remarks
+ * This class is used in the following API endpoints:
+ * - api/rains/:id/computations/:computationId?format=map
+ * - api/rains/:id/computations?format=map&begin=...
+ */
+export class RainComputationMap extends RainComputationAbstract {
+
+    /** 
+     * The map data stored as a stringified JSON array of RainMeasure objects.
+     * This format allows for efficient storage and transmission of large datasets.
+     */
+    protected map: string;
+
+    /**
+     * Creates a new RainComputationMap instance.
+     * 
+     * @param json - The configuration object containing all necessary parameters
+     * @param json.id - Unique identifier for the computation
+     * @param json.date - Timestamp of the computation
+     * @param json.isReady - Whether the computation is ready
+     * @param json.map - Array of rain measurements or stringified JSON
+     * @param json.links - Optional array of related nodes or links
+     * @param json.version - Optional version string
+     * @param json.quality - Optional quality metric (0-1)
+     * @param json.progressIngest - Optional ingestion progress (0-100)
+     * @param json.progressComputing - Optional computing progress (0-100)
+     * @param json.timeSpentInMs - Optional computation time in milliseconds
+     * @param json.isDoneDate - Optional completion timestamp
+     * @param json.launchedBy - Optional user identifier
+     * @param json.rain - Optional related rain node
+     * @param json.radars - Optional array of related radar nodes
+     */
+    constructor(json: {
+        id: string,
+        date: Date,
+        isReady: boolean,
+        map: RainMeasure[] | string,
+        links?: Link[] | RaainNode[],
+        version?: string,
+        quality?: number,
+        progressIngest?: number,
+        progressComputing?: number,
+        timeSpentInMs?: number,
+        isDoneDate?: Date,
+        launchedBy?: string,
+        rain?: Link | RaainNode,
+        radars?: Link[] | RaainNode[],
+    }) {
+        super(json);
+        this.setMapData(json.map, {mergeStrategy: MergeStrategy.NONE});
+    }
+
+    /**
+     * Converts the computation to a JSON object.
+     * 
+     * @returns A JSON object containing all relevant data
+     * @remarks
+     * This method overrides the parent class's toJSON method to handle the map property
+     * and remove the results property which is not used in this implementation.
+     */
+    public toJSON(): any {
+        const json = super.toJSON();
+        if (this.map) {
+            json['map'] = this.map;
+            delete json['results'];
+        }
+        return json;
+    }
+
+    /**
+     * Sets the map data with optional merging capabilities.
+     * 
+     * @param mapData - The rain measurement data to set
+     * @param options - Configuration options for data processing
+     * @param options.mergeStrategy - Strategy to use when merging data
+     * @param options.cartesianTools - Optional tools for coordinate transformations
+     * @param options.mergeLimitPoints - Optional boundary points for merging
+     * @param options.removeNullValues - Whether to remove null values during merge
+     * 
+     * @remarks
+     * This method handles both string and array inputs, and can perform merging
+     * operations based on the provided options. The data is always stored internally
+     * as a stringified JSON array.
+     */
+    public setMapData(mapData: RainMeasure[] | string, options: {
+        mergeStrategy: MergeStrategy,
+        cartesianTools?: CartesianTools,
+        mergeLimitPoints?: [LatLng, LatLng],
+        removeNullValues?: boolean,
+    }) {
+        if (!mapData) {
+            return;
+        }
+
+        if (typeof (mapData) !== 'string' && options.mergeStrategy !== MergeStrategy.NONE
+            && options?.cartesianTools && options?.mergeLimitPoints) {
+
+            this.buildLatLngMatrix({
+                cartesianTools: options.cartesianTools,
+                mergeLimitPoints: options.mergeLimitPoints
+            });
+
+            mapData = this.mergeRainMeasures(mapData as RainMeasure[], {
+                mergeLimitPoints: options.mergeLimitPoints,
+                removeNullValues: !!options.removeNullValues,
+                mergeStrategy: options.mergeStrategy,
+            });
+        }
+
+        this.map = typeof mapData === 'string' ? mapData : JSON.stringify(mapData);
+    }
+
+    public getMapData(): RainMeasure[] {
+        if (!this.map) {
+            return [];
+        }
+        return JSON.parse(this.map);
+    }
+}