raain-model 2.6.7 → 2.6.10

package/{polar/AbstractPolarMeasureValue.js → src/polar/AbstractPolarMeasureValue.ts}

@@ -1,88 +1,114 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractPolarMeasureValue = void 0;
-const PolarMeasureValue_1 = require("./PolarMeasureValue");
-class AbstractPolarMeasureValue {
-    constructor(json) {
-        if (!(json === null || json === void 0 ? void 0 : json.polarMeasureValue)) {
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {PolarMeasureValue} from './PolarMeasureValue';
+import {PolarValue} from './PolarValue';
+
+export class AbstractPolarMeasureValue implements IPolarMeasureValue {
+
+    public polarMeasureValue: PolarMeasureValue;
+
+    constructor(json: {
+        polarMeasureValue: AbstractPolarMeasureValue | PolarMeasureValue | string,
+    }) {
+
+        if (!json?.polarMeasureValue) {
             throw new Error('Needs one polarMeasureValue');
         }
-        let polarMeasureValue1 = json.polarMeasureValue;
+
+        let polarMeasureValue1: any = json.polarMeasureValue;
         if (typeof polarMeasureValue1 === 'string') {
             polarMeasureValue1 = JSON.parse(polarMeasureValue1);
         }
+
         if (polarMeasureValue1 instanceof AbstractPolarMeasureValue
-            || polarMeasureValue1 instanceof PolarMeasureValue_1.PolarMeasureValue) {
-            this.setPolarsAsContainer(polarMeasureValue1.getPolars(), polarMeasureValue1.getAzimuthsCount(), polarMeasureValue1.getPolarEdgesCount());
+            || polarMeasureValue1 instanceof PolarMeasureValue) {
+            this.setPolarsAsContainer(polarMeasureValue1.getPolars(),
+                polarMeasureValue1.getAzimuthsCount(),
+                polarMeasureValue1.getPolarEdgesCount());
             return;
         }
+
         let polarMeasureValue2 = polarMeasureValue1;
         if (polarMeasureValue1['polarMeasureValue']) {
             if (typeof polarMeasureValue1['polarMeasureValue'] === 'string') {
                 polarMeasureValue2 = JSON.parse(polarMeasureValue1['polarMeasureValue']);
-            }
-            else {
+            } else {
                 polarMeasureValue2 = polarMeasureValue1['polarMeasureValue'];
             }
         }
-        let azimuthsCount;
-        let polarEdgesCount;
+
+        let azimuthsCount: number;
+        let polarEdgesCount: number;
         let measureValuePolarContainers = [];
         if (polarMeasureValue2 && polarMeasureValue2['measureValuePolarContainers']) {
             measureValuePolarContainers = polarMeasureValue2['measureValuePolarContainers'];
+
             if (polarMeasureValue2['azimuthsCount'] && polarMeasureValue2['polarEdgesCount']) {
                 azimuthsCount = parseInt('' + polarMeasureValue2['azimuthsCount'], 10);
                 polarEdgesCount = parseInt('' + polarMeasureValue2['polarEdgesCount'], 10);
             }
         }
+
         if (typeof measureValuePolarContainers === 'string') {
             this.setPolarsAsString(measureValuePolarContainers, azimuthsCount, polarEdgesCount);
             return;
         }
+
         if (Array.isArray(measureValuePolarContainers)) {
             this.setPolarsAsContainer(measureValuePolarContainers, azimuthsCount, polarEdgesCount);
             return;
         }
+
         throw new Error('Needs valid polarMeasureValue');
     }
-    getPolarsStringified() {
+
+    getPolarsStringified(): string {
         return this.polarMeasureValue.getPolarsStringified();
     }
-    getPolars() {
+
+    getPolars(): MeasureValuePolarContainer[] {
         return this.polarMeasureValue.getPolars();
     }
-    setPolarsAsString(measureValuePolarContainers, azimuthsCount, polarEdgesCount) {
-        this.polarMeasureValue = new PolarMeasureValue_1.PolarMeasureValue({ measureValuePolarContainers, azimuthsCount, polarEdgesCount });
+
+    setPolarsAsString(measureValuePolarContainers: string, azimuthsCount: number, polarEdgesCount: number): void {
+        this.polarMeasureValue = new PolarMeasureValue({measureValuePolarContainers, azimuthsCount, polarEdgesCount});
     }
-    setPolarsAsContainer(measureValuePolarContainers, azimuthsCount, polarEdgesCount) {
-        this.polarMeasureValue = new PolarMeasureValue_1.PolarMeasureValue({ measureValuePolarContainers, azimuthsCount, polarEdgesCount });
+
+    setPolarsAsContainer(measureValuePolarContainers: MeasureValuePolarContainer[], azimuthsCount: number, polarEdgesCount: number): void {
+        this.polarMeasureValue = new PolarMeasureValue({measureValuePolarContainers, azimuthsCount, polarEdgesCount});
     }
-    getPolarValue(json) {
+
+    getPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number }): PolarValue {
         return this.polarMeasureValue.getPolarValue(json);
     }
-    setPolarValue(json) {
+
+    setPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number, value: number }): void {
         return this.polarMeasureValue.setPolarValue(json);
     }
-    getAzimuthsCount() {
+
+    getAzimuthsCount(): number {
         return this.polarMeasureValue.getAzimuthsCount();
     }
-    getPolarEdgesCount() {
+
+    getPolarEdgesCount(): number {
         return this.polarMeasureValue.getPolarEdgesCount();
     }
-    toJSON(options = {
+
+    public toJSON(options = {
         stringify: false
-    }) {
-        let polarMeasureValue = this.polarMeasureValue;
-        if (options === null || options === void 0 ? void 0 : options.stringify) {
+    }): any {
+
+        let polarMeasureValue: any = this.polarMeasureValue;
+        if (options?.stringify) {
             polarMeasureValue = JSON.stringify(this.polarMeasureValue.toJSONWithPolarStringified());
         }
+
         return {
             polarMeasureValue,
         };
     }
-    toJSONWithPolarStringified() {
-        return this.toJSON({ stringify: true });
+
+    public toJSONWithPolarStringified(): any {
+        return this.toJSON({stringify: true});
     }
 }
-exports.AbstractPolarMeasureValue = AbstractPolarMeasureValue;
-//# sourceMappingURL=AbstractPolarMeasureValue.js.map

package/src/polar/IPolarMeasureValue.ts

@@ -0,0 +1,21 @@
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {PolarValue} from './PolarValue';
+
+export interface IPolarMeasureValue {
+
+    getAzimuthsCount(): number;
+
+    getPolarEdgesCount(): number;
+
+    getPolarsStringified(): string;
+
+    getPolars(): MeasureValuePolarContainer[];
+
+    toJSON(options?: any): any;
+
+    toJSONWithPolarStringified(): any;
+
+    getPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number }): PolarValue;
+
+    setPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number, value: number }): void;
+}

package/{polar/MeasureValuePolarContainer.js → src/polar/MeasureValuePolarContainer.ts}

@@ -1,34 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeasureValuePolarContainer = void 0;
-class MeasureValuePolarContainer {
-    constructor(json) {
-        if (typeof (json === null || json === void 0 ? void 0 : json.azimuth) === 'undefined') {
+export class MeasureValuePolarContainer {
+
+    public azimuth: number;         // In degrees. 0° = North, 90°= Est, 180° = South, 270°= West.
+    public distance: number;        // In meters. Edge distance.
+    public polarEdges: number[];    // Edge Dbz values.
+    public edgeOffset: number;      // Edge Offset. Count of edges before the edge values. polarEdges can start from this offset.
+
+    constructor(json: {
+        azimuth: number,
+        distance: number,
+        polarEdges: number[],
+        edgeOffset?: number,
+    }) {
+
+        if (typeof json?.azimuth === 'undefined') {
             throw new Error('MeasureValuePolarContainer needs a valid Object');
         }
+
         this.azimuth = json.azimuth;
         this.distance = json.distance;
         this.polarEdges = json.polarEdges;
         this.edgeOffset = json.edgeOffset ? json.edgeOffset : 0;
     }
-    toJSON() {
+
+    public toJSON(): any {
         return {
             azimuth: this.azimuth,
             distance: this.distance,
             polarEdges: this.polarEdges,
             edgeOffset: this.edgeOffset,
-        };
+        } as any;
     }
+
     getPolarEdgesCount() {
         return this.edgeOffset + this.polarEdges.length;
     }
+
     getNotNullValuesCount() {
         const edges = this.polarEdges.filter(e => !!e);
         return edges.length;
     }
-    getFiltered(options = { nullValues: true }) {
+
+    getFiltered(options = {nullValues: true}): MeasureValuePolarContainer {
         let polarEdges = this.polarEdges.map(e => 1 - 1 + e);
         let edgeOffset = this.edgeOffset + 1 - 1;
+
         if (options.nullValues) {
             const firstNonNullValue = polarEdges.findIndex(value => !!value);
             const lastNonNullValue = polarEdges.reduce((lastIndex, value, currentIndex) => {
@@ -37,17 +52,19 @@ class MeasureValuePolarContainer {
                 }
                 return lastIndex;
             }, -1);
+
             if (firstNonNullValue >= 0 && lastNonNullValue >= 0) {
                 polarEdges = polarEdges.slice(firstNonNullValue, lastNonNullValue + 1);
                 edgeOffset = edgeOffset + firstNonNullValue;
-            }
-            else {
+            } else {
                 polarEdges = [];
             }
+
             if (polarEdges.length === 0) {
                 edgeOffset = 0;
             }
         }
+
         return new MeasureValuePolarContainer({
             azimuth: this.azimuth,
             distance: this.distance,
@@ -55,9 +72,8 @@ class MeasureValuePolarContainer {
             edgeOffset,
         });
     }
+
     getDistance() {
         return this.distance;
     }
 }
-exports.MeasureValuePolarContainer = MeasureValuePolarContainer;
-//# sourceMappingURL=MeasureValuePolarContainer.js.map

package/src/polar/PolarFilter.ts

@@ -0,0 +1,46 @@
+export class PolarFilter {
+    azimuthMin: number;
+    azimuthMax: number;
+    edgeMin: number;
+    edgeMax: number;
+
+    constructor(json?: {
+        azimuthMin?: number;
+        azimuthMax?: number;
+        edgeMin?: number;
+        edgeMax?: number;
+    }) {
+        if (typeof json?.azimuthMin !== 'undefined') this.azimuthMin = json.azimuthMin;
+        if (typeof json?.azimuthMax !== 'undefined') this.azimuthMax = json.azimuthMax;
+        if (typeof json?.edgeMin !== 'undefined') this.edgeMin = json.edgeMin;
+        if (typeof json?.edgeMax !== 'undefined') this.edgeMax = json.edgeMax;
+    }
+
+    protected static min(a: number, b: number): number {
+        if (typeof a === 'undefined') return b;
+        if (typeof b === 'undefined') return a;
+        return Math.min(a, b);
+    }
+
+    protected static max(a: number, b: number): number {
+        if (typeof a === 'undefined') return b;
+        if (typeof b === 'undefined') return a;
+        return Math.max(a, b);
+    }
+
+    merging(polarFilter?: PolarFilter): PolarFilter {
+        return new PolarFilter({
+            azimuthMin: PolarFilter.max(polarFilter?.azimuthMin, this.azimuthMin),
+            azimuthMax: PolarFilter.min(polarFilter?.azimuthMax, this.azimuthMax),
+            edgeMin: PolarFilter.max(polarFilter?.edgeMin, this.edgeMin),
+            edgeMax: PolarFilter.min(polarFilter?.edgeMax, this.edgeMax),
+        });
+    }
+
+    equal(polarFilter: PolarFilter): boolean {
+        return this.azimuthMin === polarFilter.azimuthMin &&
+            this.azimuthMax === polarFilter.azimuthMax &&
+            this.edgeMin === polarFilter.edgeMin &&
+            this.edgeMax === polarFilter.edgeMax;
+    }
+}

package/{polar/PolarMeasureValue.js → src/polar/PolarMeasureValue.ts}

@@ -1,106 +1,143 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolarMeasureValue = void 0;
-const MeasureValuePolarContainer_1 = require("./MeasureValuePolarContainer");
-const PolarValue_1 = require("./PolarValue");
-const AbstractPolarMeasureValue_1 = require("./AbstractPolarMeasureValue");
-class PolarMeasureValue {
-    constructor(json) {
+import {MeasureValuePolarContainer} from './MeasureValuePolarContainer';
+import {IPolarMeasureValue} from './IPolarMeasureValue';
+import {PolarValue} from './PolarValue';
+import {AbstractPolarMeasureValue} from './AbstractPolarMeasureValue';
+
+export class PolarMeasureValue implements IPolarMeasureValue {
+
+    protected measureValuePolarContainers: MeasureValuePolarContainer[];
+    protected azimuthsCount: number;
+    protected polarEdgesCount: number;
+
+    constructor(json: {
+        measureValuePolarContainers: MeasureValuePolarContainer[] | string,
+        azimuthsCount?: number,
+        polarEdgesCount?: number,
+    } | string) {
+
         if (typeof json === 'string') {
-            json = JSON.parse(json);
+            json = JSON.parse(json) as {
+                measureValuePolarContainers: MeasureValuePolarContainer[] | string,
+                azimuthsCount: number,
+                polarEdgesCount: number,
+            };
         }
+
         if (typeof json.measureValuePolarContainers === 'string') {
+
             this.setPolarsAsString(json.measureValuePolarContainers);
-        }
-        else if (json.measureValuePolarContainers instanceof AbstractPolarMeasureValue_1.AbstractPolarMeasureValue
+
+        } else if (json.measureValuePolarContainers instanceof AbstractPolarMeasureValue
             || json.measureValuePolarContainers instanceof PolarMeasureValue) {
+
             this.setPolarsAsContainer(json.measureValuePolarContainers.getPolars());
-        }
-        else {
+
+        } else {
             this.setPolarsAsContainer(json.measureValuePolarContainers);
         }
-        if (!((json === null || json === void 0 ? void 0 : json.azimuthsCount) >= 0) || !((json === null || json === void 0 ? void 0 : json.polarEdgesCount) >= 0)) {
+
+        if (!(json?.azimuthsCount >= 0) || !(json?.polarEdgesCount >= 0)) {
             // throw new Error('PolarMeasureValue needs valid azimuthsCount & polarEdgesCount');
             this.countUnknown();
-        }
-        else {
+        } else {
             this.azimuthsCount = json.azimuthsCount;
             this.polarEdgesCount = json.polarEdgesCount;
         }
     }
-    getAzimuthsCount() {
+
+    getAzimuthsCount(): number {
         if (this.azimuthsCount < 0) {
             this.count();
         }
         return this.azimuthsCount;
     }
-    getPolarEdgesCount() {
+
+    getPolarEdgesCount(): number {
         if (this.polarEdgesCount < 0) {
             this.count();
         }
         return this.polarEdgesCount;
     }
-    getPolarsStringified() {
+
+    getPolarsStringified(): string {
         return JSON.stringify(this.getPolars());
     }
-    getPolars() {
+
+    getPolars(): MeasureValuePolarContainer[] {
         return this.measureValuePolarContainers;
     }
-    setPolarsAsString(s) {
+
+    setPolarsAsString(s: string): void {
         try {
             let polars = JSON.parse(s);
+
             if (polars && polars.measureValuePolarContainers) {
                 polars = polars.measureValuePolarContainers;
             }
+
             if (typeof polars === 'string') {
                 polars = JSON.parse(polars);
             }
-            this.measureValuePolarContainers = polars.map(convertedPolar => new MeasureValuePolarContainer_1.MeasureValuePolarContainer(convertedPolar));
-        }
-        catch (e) {
+
+            this.measureValuePolarContainers = polars.map(convertedPolar => new MeasureValuePolarContainer(convertedPolar));
+        } catch (e) {
             // console.warn('setPolarsAsString pb: ', e, typeof s, s);
             this.measureValuePolarContainers = [];
         }
+
         this.countUnknown();
     }
-    setPolarsAsContainer(measureValuePolarContainers, options = { resetCount: true }) {
-        let parsed = measureValuePolarContainers ? measureValuePolarContainers : [];
+
+    setPolarsAsContainer(measureValuePolarContainers: MeasureValuePolarContainer[],
+                         options = {resetCount: true}): void {
+        let parsed: any = measureValuePolarContainers ? measureValuePolarContainers : [];
         if (!('length' in parsed)) {
             parsed = [];
         }
         this.measureValuePolarContainers = parsed;
+
         if (options.resetCount) {
             this.countUnknown();
         }
     }
-    getPolarValue(json) {
+
+    getPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number }): PolarValue {
+
         if (json.azimuthInDegrees < 0 || json.azimuthInDegrees > 360) {
             console.warn('### raain-model > getPolarValue : strange azimuth:', json.azimuthInDegrees);
             return null;
         }
+
         let edgeValue = 0;
         let distance = this.getDefaultDistance();
+
         const measureValuePolarContainersFound = this.measureValuePolarContainers
             .filter(c => c.azimuth === json.azimuthInDegrees);
         if (measureValuePolarContainersFound.length === 1) {
+
             const measureValuePolarContainer = measureValuePolarContainersFound[0];
             distance = measureValuePolarContainer.distance;
             const edgeIndex = (json.distanceInMeters / distance) - 1 - measureValuePolarContainer.edgeOffset;
+
             if (0 <= edgeIndex && edgeIndex < measureValuePolarContainer.polarEdges.length) {
                 edgeValue = measureValuePolarContainer.polarEdges[edgeIndex];
             }
         }
-        return new PolarValue_1.PolarValue({
+
+        return new PolarValue({
             value: edgeValue,
             polarAzimuthInDegrees: json.azimuthInDegrees,
             polarDistanceInMeters: json.distanceInMeters
         });
     }
-    setPolarValue(json) {
+
+    setPolarValue(json: { azimuthInDegrees: number, distanceInMeters: number, value: number }): void {
+
         if (json.azimuthInDegrees < 0 || json.azimuthInDegrees > 360) {
             console.warn('### raain-model > setPolarValue : strange azimuth:', json.azimuthInDegrees);
             return null;
         }
+
         let distance = this.getDefaultDistance();
         const azimuth = json.azimuthInDegrees;
         const found = this.measureValuePolarContainers.filter(c => c.azimuth === azimuth);
@@ -108,71 +145,93 @@ class PolarMeasureValue {
             const measureValuePolarContainer = found[0];
             distance = measureValuePolarContainer.distance;
             const edgeIndex = (json.distanceInMeters / distance) - 1 - measureValuePolarContainer.edgeOffset;
+
             if (0 <= edgeIndex && edgeIndex < measureValuePolarContainer.polarEdges.length) {
                 measureValuePolarContainer.polarEdges[edgeIndex] = json.value;
-            }
-            else {
+            } else {
                 console.warn('### raain-model > setPolarValue : extending polarEdges');
                 let diff = edgeIndex - measureValuePolarContainer.polarEdges.length;
                 if (edgeIndex < 0) {
                     diff = -1 - edgeIndex;
                     measureValuePolarContainer.edgeOffset += edgeIndex;
                 }
+
                 const arrayWithNullValuesToAdd = new Array(diff).fill(0);
+
                 if (edgeIndex < 0) {
-                    measureValuePolarContainer.polarEdges = [json.value].concat(arrayWithNullValuesToAdd.concat(measureValuePolarContainer.polarEdges));
-                }
-                else if (edgeIndex > 0) {
-                    measureValuePolarContainer.polarEdges = measureValuePolarContainer.polarEdges.concat(arrayWithNullValuesToAdd.concat([json.value]));
+                    measureValuePolarContainer.polarEdges = [json.value].concat(
+                        arrayWithNullValuesToAdd.concat(measureValuePolarContainer.polarEdges));
+                } else if (edgeIndex > 0) {
+                    measureValuePolarContainer.polarEdges = measureValuePolarContainer.polarEdges.concat(
+                        arrayWithNullValuesToAdd.concat([json.value]));
                 }
             }
-        }
-        else if (found.length === 0) {
+        } else if (found.length === 0) {
             console.warn('### raain-model > setPolarValue : extending measureValuePolarContainers');
             const polarEdges = [json.value];
             const edgeOffset = json.distanceInMeters / distance - 1;
-            this.measureValuePolarContainers.push(new MeasureValuePolarContainer_1.MeasureValuePolarContainer({ azimuth, distance, polarEdges, edgeOffset }));
+            this.measureValuePolarContainers.push(new MeasureValuePolarContainer({azimuth, distance, polarEdges, edgeOffset}));
         }
     }
-    iterate(onEachValue) {
+
+    iterate(onEachValue: (
+        polarValue: PolarValue,
+        azimuthIndex: number,
+        edgeIndex: number,
+        valueSetter: (newValue: number) => void
+    ) => void) {
+
         for (const measureValuePolarContainer of this.measureValuePolarContainers) {
             const azimuth = measureValuePolarContainer.azimuth;
             const distance = measureValuePolarContainer.distance;
             const polarEdges = measureValuePolarContainer.polarEdges;
+
             const azimuthIndex = azimuth * this.getAzimuthsCount() / 360;
             for (const [edgeIndex, value] of polarEdges.entries()) {
+
                 const edgeAbsoluteIndex = edgeIndex + measureValuePolarContainer.edgeOffset;
-                const valueSetter = (newValue) => {
+
+                const valueSetter = (newValue: number) => {
                     polarEdges[edgeIndex] = newValue;
                 };
-                onEachValue(new PolarValue_1.PolarValue({
-                    value,
-                    polarAzimuthInDegrees: azimuth,
-                    polarDistanceInMeters: distance * (edgeAbsoluteIndex + 1)
-                }), azimuthIndex, edgeAbsoluteIndex, valueSetter);
+
+                onEachValue(
+                    new PolarValue({
+                        value,
+                        polarAzimuthInDegrees: azimuth,
+                        polarDistanceInMeters: distance * (edgeAbsoluteIndex + 1)
+                    }),
+                    azimuthIndex,
+                    edgeAbsoluteIndex,
+                    valueSetter);
             }
         }
     }
-    toJSON() {
+
+    public toJSON() {
         return {
             measureValuePolarContainers: this.getPolars(),
             azimuthsCount: this.getAzimuthsCount(),
             polarEdgesCount: this.getPolarEdgesCount(),
         };
     }
-    toJSONWithPolarStringified() {
+
+    public toJSONWithPolarStringified() {
         return {
             measureValuePolarContainers: this.getPolarsStringified(),
             azimuthsCount: this.getAzimuthsCount(),
             polarEdgesCount: this.getPolarEdgesCount(),
         };
     }
-    getFiltered(options = {
+
+    public getFiltered(options = {
         nullValues: true,
         ordered: false
-    }) {
+    }): PolarMeasureValue {
+
         const azimuthsCount = this.getAzimuthsCount();
         const polarEdgesCount = this.getPolarEdgesCount();
+
         let measureValuePolarContainers = [];
         for (const measureValuePolarContainer of this.measureValuePolarContainers) {
             let filteredMeasureValuePolarContainer = measureValuePolarContainer;
@@ -181,53 +240,57 @@ class PolarMeasureValue {
                 if (options.nullValues && filteredMeasureValuePolarContainer.getNotNullValuesCount()) {
                     measureValuePolarContainers.push(filteredMeasureValuePolarContainer);
                 }
-            }
-            else {
+            } else {
                 measureValuePolarContainers.push(filteredMeasureValuePolarContainer);
             }
         }
+
         if (options.ordered) {
             measureValuePolarContainers = measureValuePolarContainers.sort((a, b) => a.azimuth - b.azimuth);
         }
-        return new PolarMeasureValue({ measureValuePolarContainers, azimuthsCount, polarEdgesCount });
+
+        return new PolarMeasureValue({measureValuePolarContainers, azimuthsCount, polarEdgesCount});
     }
-    getValuesCount() {
+
+    public getValuesCount(): number {
         return this.getAzimuthsCount() * this.getPolarEdgesCount();
     }
-    getNotNullValuesCount() {
+
+    public getNotNullValuesCount(): number {
         let count = 0;
         for (const [a, measureValuePolarContainer] of this.getPolars().entries()) {
             count += measureValuePolarContainer.getNotNullValuesCount();
         }
         return count;
     }
-    getDefaultDistance() {
+
+    public getDefaultDistance() {
         let distance = 1000;
         if (this.measureValuePolarContainers.length > 0) {
             distance = this.measureValuePolarContainers[0].distance;
         }
         return distance;
     }
-    getHash(hash) {
+
+    public getHash(hash?: (arg0: any) => number | string): string {
         if (!hash) {
             return '' + this.getPolars();
         }
         return '' + hash(this.getPolars());
     }
-    count() {
+
+    protected count() {
         const measureValuePolarContainers = this.getPolars();
         this.azimuthsCount = measureValuePolarContainers.length;
         if (this.azimuthsCount > 0) {
             this.polarEdgesCount = measureValuePolarContainers[0].polarEdges.length;
-        }
-        else {
+        } else {
             this.polarEdgesCount = 0;
         }
     }
-    countUnknown() {
+
+    protected countUnknown() {
         this.azimuthsCount = -1;
         this.polarEdgesCount = -1;
     }
 }
-exports.PolarMeasureValue = PolarMeasureValue;
-//# sourceMappingURL=PolarMeasureValue.js.map