scichart 2.0.2228 → 2.1.0-beta.40

package/Charting/Model/XyyDataSeries.js

@@ -20,7 +20,7 @@ var Deleter_1 = require("../../Core/Deleter");
 var Guard_1 = require("../../Core/Guard");
 var NumberRange_1 = require("../../Core/NumberRange");
 var NumberArray_1 = require("../../types/NumberArray");
-var fillDoubleVectorFromJsArray_1 = require("../../utils/ccall/fillDoubleVectorFromJsArray");
+var appendDoubleVectorFromJsArray_1 = require("../../utils/ccall/appendDoubleVectorFromJsArray");
 var animationHelpers_1 = require("../Visuals/RenderableSeries/Animations/animationHelpers");
 var BaseDataSeries_1 = require("./BaseDataSeries");
 var IDataSeries_1 = require("./IDataSeries");
@@ -49,9 +49,9 @@ var XyyDataSeries = /** @class */ (function (_super) {
         var _this = _super.call(this, webAssemblyContext, options) || this;
         /** @inheritDoc */
         _this.type = IDataSeries_1.EDataSeriesType.Xyy;
-        _this.y1Values = new webAssemblyContext.DoubleVector();
-        _this.y1InitialAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.y1FinalAnimationValues = new webAssemblyContext.DoubleVector();
+        _this.y1Values = new webAssemblyContext.SCRTDoubleVector();
+        _this.y1InitialAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.y1FinalAnimationValues = new webAssemblyContext.SCRTDoubleVector();
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             Guard_1.Guard.notNull(options.yValues, "options.yValues");
             Guard_1.Guard.notNull(options.y1Values, "options.y1Values");
@@ -78,9 +78,11 @@ var XyyDataSeries = /** @class */ (function (_super) {
      */
     XyyDataSeries.prototype.append = function (x, y, y1, metadata) {
         if (!this.getIsDeleted()) {
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, [x], [y]);
             // Push metadata should be done before push x values
             this.appendMetadata(metadata);
-            this.getNativeXValues().push_back(x);
+            nativeX.push_back(x);
             this.getNativeYValues().push_back(y);
             this.getNativeY1Values().push_back(y1);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, 1);
@@ -111,11 +113,12 @@ var XyyDataSeries = /** @class */ (function (_super) {
                 Guard_1.Guard.isTrue(Array.isArray(metadata), "metadata must be an array of IPointMetadata");
                 Guard_1.Guard.arraysSameLength(xValues, "xValues", metadata, "metadata");
             }
-            // Push metadata should be done before push x values
-            this.appendMetadataRange(metadata, xValues.length);
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
             var nativeY1 = this.getNativeY1Values();
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, xValues, yValues);
+            // Push metadata should be done before push x values
+            this.appendMetadataRange(metadata, xValues.length);
             // Old implementation with copying each element
             // for (let i = 0; i < xValues.length; i++) {
             //     nativeX.push_back(xValues[i]);
@@ -123,9 +126,9 @@ var XyyDataSeries = /** @class */ (function (_super) {
             //     nativeY1.push_back(y1Values[i]);
             // }
             // New implementation passing array from JS
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY1, y1Values);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY1, y1Values);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, xValues.length);
         }
     };
@@ -140,6 +143,7 @@ var XyyDataSeries = /** @class */ (function (_super) {
     XyyDataSeries.prototype.update = function (index, y, y1, metadata) {
         if (!this.getIsDeleted()) {
             this.validateIndex(index);
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, undefined, undefined, [y], index);
             this.getNativeYValues().set(index, y);
             this.getNativeY1Values().set(index, y1);
             this.setMetadataAt(index, metadata);
@@ -157,7 +161,10 @@ var XyyDataSeries = /** @class */ (function (_super) {
      */
     XyyDataSeries.prototype.updateXyy1 = function (index, x, y, y1, metadata) {
         if (!this.getIsDeleted()) {
-            this.getNativeXValues().set(index, x);
+            this.validateIndex(index);
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, nativeX, [x], [y], index);
+            nativeX.set(index, x);
             this.getNativeYValues().set(index, y);
             this.getNativeY1Values().set(index, y1);
             this.setMetadataAt(index, metadata);
@@ -182,6 +189,7 @@ var XyyDataSeries = /** @class */ (function (_super) {
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
             var nativeY1 = this.getNativeY1Values();
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, [x], [y], startIndex);
             nativeX.insertAt(startIndex, x);
             nativeY.insertAt(startIndex, y);
             nativeY1.insertAt(startIndex, y1);
@@ -214,16 +222,11 @@ var XyyDataSeries = /** @class */ (function (_super) {
                 Guard_1.Guard.isTrue(Array.isArray(metadata), "metadata must be an array of IPointMetadata");
                 Guard_1.Guard.arraysSameLength(xValues, "xValues", metadata, "metadata");
             }
-            var rangeLength = xValues.length;
             var nativeX = this.getNativeXValues();
-            var nativeY = this.getNativeYValues();
-            var nativeY1 = this.getNativeY1Values();
-            var tempStartIndex = startIndex;
-            for (var i = 0; i < rangeLength; i++, tempStartIndex++) {
-                nativeX.insertAt(tempStartIndex, xValues[i]);
-                nativeY.insertAt(tempStartIndex, yValues[i]);
-                nativeY1.insertAt(tempStartIndex, y1Values[i]);
-            }
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, xValues, yValues, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, xValues, nativeX, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, yValues, this.getNativeYValues(), startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, y1Values, this.getNativeY1Values(), startIndex);
             this.insertMetadataRange(startIndex, metadata);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Insert, startIndex, xValues.length);
         }
@@ -269,7 +272,7 @@ var XyyDataSeries = /** @class */ (function (_super) {
      */
     XyyDataSeries.prototype.clear = function () {
         if (!this.getIsDeleted()) {
-            this.getNativeIndexes().clear();
+            _super.prototype.clear.call(this);
             this.getNativeXValues().clear();
             this.getNativeYValues().clear();
             this.getNativeY1Values().clear();

package/Charting/Model/XyzDataSeries.d.ts

@@ -1,5 +1,5 @@
 import { NumberArray } from "../../types/NumberArray";
-import { DoubleVector, TSciChart } from "../../types/TSciChart";
+import { SCRTDoubleVector, TSciChart } from "../../types/TSciChart";
 import { SeriesAnimation } from "../Visuals/RenderableSeries/Animations/SeriesAnimation";
 import { BaseDataSeries, IBaseDataSeriesOptions } from "./BaseDataSeries";
 import { EDataSeriesType } from "./IDataSeries";
@@ -40,12 +40,12 @@ export declare class XyzDataSeries extends BaseDataSeries {
     /**
      * Z vector with initial animation values
      */
-    zInitialAnimationValues: DoubleVector;
+    zInitialAnimationValues: SCRTDoubleVector;
     /**
      * Z vector with final animation values
      */
-    zFinalAnimationValues: DoubleVector;
-    protected zValues: DoubleVector;
+    zFinalAnimationValues: SCRTDoubleVector;
+    protected zValues: SCRTDoubleVector;
     /**
      * Creates an instance of {@link XyzDataSeries}
      * @param webAssemblyContext the {@link TSciChart | SciChart WebAssembly Context} containing native methods
@@ -56,7 +56,7 @@ export declare class XyzDataSeries extends BaseDataSeries {
     /**
      * Gets a native / WebAssembly vector of Z-values in the DataSeries
      */
-    getNativeZValues(): DoubleVector;
+    getNativeZValues(): SCRTDoubleVector;
     /**
      * Appends a single X, Y, Z point to the DataSeries
      * @remarks

package/Charting/Model/XyzDataSeries.js

@@ -19,7 +19,7 @@ exports.XyzDataSeries = void 0;
 var Deleter_1 = require("../../Core/Deleter");
 var Guard_1 = require("../../Core/Guard");
 var NumberArray_1 = require("../../types/NumberArray");
-var fillDoubleVectorFromJsArray_1 = require("../../utils/ccall/fillDoubleVectorFromJsArray");
+var appendDoubleVectorFromJsArray_1 = require("../../utils/ccall/appendDoubleVectorFromJsArray");
 var animationHelpers_1 = require("../Visuals/RenderableSeries/Animations/animationHelpers");
 var BaseDataSeries_1 = require("./BaseDataSeries");
 var IDataSeries_1 = require("./IDataSeries");
@@ -48,9 +48,9 @@ var XyzDataSeries = /** @class */ (function (_super) {
         var _this = _super.call(this, webAssemblyContext, options) || this;
         /** @inheritDoc */
         _this.type = IDataSeries_1.EDataSeriesType.Xyz;
-        _this.zValues = new webAssemblyContext.DoubleVector();
-        _this.zInitialAnimationValues = new webAssemblyContext.DoubleVector();
-        _this.zFinalAnimationValues = new webAssemblyContext.DoubleVector();
+        _this.zValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.zInitialAnimationValues = new webAssemblyContext.SCRTDoubleVector();
+        _this.zFinalAnimationValues = new webAssemblyContext.SCRTDoubleVector();
         if (options === null || options === void 0 ? void 0 : options.xValues) {
             Guard_1.Guard.notNull(options.yValues, "options.yValues");
             Guard_1.Guard.notNull(options.zValues, "options.zValues");
@@ -77,9 +77,11 @@ var XyzDataSeries = /** @class */ (function (_super) {
      */
     XyzDataSeries.prototype.append = function (x, y, z, metadata) {
         if (!this.getIsDeleted()) {
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, [x], [y]);
             // Push metadata should be done before push x values
             this.appendMetadata(metadata);
-            this.getNativeXValues().push_back(x);
+            nativeX.push_back(x);
             this.getNativeYValues().push_back(y);
             this.getNativeZValues().push_back(z);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, 1);
@@ -110,14 +112,15 @@ var XyzDataSeries = /** @class */ (function (_super) {
                 Guard_1.Guard.isTrue(Array.isArray(metadata), "metadata must be an array of IPointMetadata");
                 Guard_1.Guard.arraysSameLength(xValues, "xValues", metadata, "metadata");
             }
-            // Push metadata should be done before push x values
-            this.appendMetadataRange(metadata, xValues.length);
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
             var nativeZ = this.getNativeZValues();
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
-            (0, fillDoubleVectorFromJsArray_1.fillDoubleVectorFromJsArray)(this.webAssemblyContext, nativeZ, zValues);
+            this.dataDistributionCalculator.onAppend(this.isSorted, this.containsNaN, nativeX, xValues, yValues);
+            // Push metadata should be done before push x values
+            this.appendMetadataRange(metadata, xValues.length);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeX, xValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeY, yValues);
+            (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext, nativeZ, zValues);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Append, null, xValues.length);
         }
     };
@@ -132,6 +135,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
     XyzDataSeries.prototype.update = function (index, y, z, metadata) {
         if (!this.getIsDeleted()) {
             this.validateIndex(index);
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, undefined, undefined, [y], index);
             this.getNativeYValues().set(index, y);
             this.getNativeZValues().set(index, z);
             this.setMetadataAt(index, metadata);
@@ -149,7 +153,10 @@ var XyzDataSeries = /** @class */ (function (_super) {
      */
     XyzDataSeries.prototype.updateXyz = function (index, x, y, z, metadata) {
         if (!this.getIsDeleted()) {
-            this.getNativeXValues().set(index, x);
+            this.validateIndex(index);
+            var nativeX = this.getNativeXValues();
+            this.dataDistributionCalculator.onUpdate(this.isSorted, this.containsNaN, nativeX, [x], [y], index);
+            nativeX.set(index, x);
             this.getNativeYValues().set(index, y);
             this.getNativeZValues().set(index, z);
             this.setMetadataAt(index, metadata);
@@ -174,6 +181,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
             var nativeX = this.getNativeXValues();
             var nativeY = this.getNativeYValues();
             var nativeZ = this.getNativeZValues();
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, [x], [y], startIndex);
             nativeX.insertAt(startIndex, x);
             nativeY.insertAt(startIndex, y);
             nativeZ.insertAt(startIndex, z);
@@ -206,16 +214,11 @@ var XyzDataSeries = /** @class */ (function (_super) {
                 Guard_1.Guard.isTrue(Array.isArray(metadata), "metadata must be an array of IPointMetadata");
                 Guard_1.Guard.arraysSameLength(xValues, "xValues", metadata, "metadata");
             }
-            var rangeLength = xValues.length;
             var nativeX = this.getNativeXValues();
-            var nativeY = this.getNativeYValues();
-            var nativeZ = this.getNativeZValues();
-            var tempStartIndex = startIndex;
-            for (var i = 0; i < rangeLength; i++, tempStartIndex++) {
-                nativeX.insertAt(tempStartIndex, xValues[i]);
-                nativeY.insertAt(tempStartIndex, yValues[i]);
-                nativeZ.insertAt(tempStartIndex, zValues[i]);
-            }
+            this.dataDistributionCalculator.onInsert(this.isSorted, this.containsNaN, nativeX, xValues, yValues, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, xValues, nativeX, startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, yValues, this.getNativeYValues(), startIndex);
+            (0, appendDoubleVectorFromJsArray_1.insertDoubleVectorFromJsArray)(this.webAssemblyContext, zValues, this.getNativeZValues(), startIndex);
             this.insertMetadataRange(startIndex, metadata);
             this.notifyDataChanged(IDataSeries_1.EDataChangeType.Insert, startIndex, xValues.length);
         }
@@ -261,7 +264,7 @@ var XyzDataSeries = /** @class */ (function (_super) {
      */
     XyzDataSeries.prototype.clear = function () {
         if (!this.getIsDeleted()) {
-            this.getNativeIndexes().clear();
+            _super.prototype.clear.call(this);
             this.getNativeXValues().clear();
             this.getNativeYValues().clear();
             this.getNativeZValues().clear();

package/Charting/Numerics/CoordinateCalculators/CategoryCoordinateCalculator.d.ts

@@ -1,4 +1,4 @@
-import { DoubleVector, TSciChart } from "../../../types/TSciChart";
+import { SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
 import { CoordinateCalculatorBase } from "./CoordinateCalculatorBase";
 /**
  * Provides an implementation of Numeric {@link CoordinateCalculatorBase | Coordinate Calculator} which transforms
@@ -34,7 +34,7 @@ export declare class CategoryCoordinateCalculator extends CoordinateCalculatorBa
     /**
      * The primary chart series X-values, required for category calculations and interpolation / extrapolation
      */
-    baseXValues: DoubleVector;
+    baseXValues: SCRTDoubleVector;
     /**
      * Creates an instance of CategoryCoordinateCalculator
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}

package/Charting/Numerics/CoordinateCalculators/FlippedCategoryCoordinateCalculator.d.ts

@@ -1,4 +1,4 @@
-import { DoubleVector, TSciChart } from "../../../types/TSciChart";
+import { SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
 import { CoordinateCalculatorBase } from "./CoordinateCalculatorBase";
 /**
  * Provides an implementation of Numeric {@link CoordinateCalculatorBase | Coordinate Calculator} which transforms
@@ -35,7 +35,7 @@ export declare class FlippedCategoryCoordinateCalculator extends CoordinateCalcu
     /**
      * The primary chart series X-values, required for category calculations and interpolation / extrapolation
      */
-    baseXValues: DoubleVector;
+    baseXValues: SCRTDoubleVector;
     /**
      * Creates an instance of FlippedCategoryCoordinateCalculator
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} or {@link TSciChart2D | SciChart 2D WebAssembly Context}

package/Charting/Numerics/CoordinateCalculators/FlippedNumericCoordinateCalculator.d.ts

@@ -32,6 +32,7 @@ export declare class FlippedNumericCoordinateCalculator extends CoordinateCalcul
      * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing
      * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing
      * @param offset A constant pixel offset used in coordinate calculations
+     * @param allowFastMath When true, calculate using 32-bit floating point values (faster, but less accurate)
      */
-    constructor(webAssemblyContext: TSciChart | TSciChart3D, viewportDimension: number, visibleMin: number, visibleMax: number, offset?: number);
+    constructor(webAssemblyContext: TSciChart | TSciChart3D, viewportDimension: number, visibleMin: number, visibleMax: number, offset?: number, allowFastMath?: boolean);
 }

package/Charting/Numerics/CoordinateCalculators/FlippedNumericCoordinateCalculator.js

@@ -49,11 +49,15 @@ var FlippedNumericCoordinateCalculator = /** @class */ (function (_super) {
      * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing
      * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing
      * @param offset A constant pixel offset used in coordinate calculations
+     * @param allowFastMath When true, calculate using 32-bit floating point values (faster, but less accurate)
      */
-    function FlippedNumericCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset) {
+    function FlippedNumericCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, allowFastMath) {
         if (offset === void 0) { offset = 0; }
+        if (allowFastMath === void 0) { allowFastMath = false; }
         var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, true) || this;
-        _this.nativeCalculator = new webAssemblyContext.FlippedLinearCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset);
+        _this.nativeCalculator = allowFastMath
+            ? new webAssemblyContext.FlippedLinearCoordinateCalculatorSingle(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset)
+            : new webAssemblyContext.FlippedLinearCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset);
         return _this;
     }
     return FlippedNumericCoordinateCalculator;

package/Charting/Numerics/CoordinateCalculators/NumericCoordinateCalculator.d.ts

@@ -31,6 +31,7 @@ export declare class NumericCoordinateCalculator extends CoordinateCalculatorBas
      * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing
      * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing
      * @param offset A constant pixel offset used in coordinate calculations
+     * @param allowFastMath When true, calculate using 32-bit floating point values (faster, but less accurate)
      */
-    constructor(webAssemblyContext: TSciChart | TSciChart3D, viewportDimension: number, visibleMin: number, visibleMax: number, offset?: number);
+    constructor(webAssemblyContext: TSciChart | TSciChart3D, viewportDimension: number, visibleMin: number, visibleMax: number, offset?: number, allowFastMath?: boolean);
 }

package/Charting/Numerics/CoordinateCalculators/NumericCoordinateCalculator.js

@@ -48,11 +48,15 @@ var NumericCoordinateCalculator = /** @class */ (function (_super) {
      * @param visibleMin The {@link AxisCore.visibleRange}.min at the time of drawing
      * @param visibleMax The {@link AxisCore.visibleRange}.max at the time of drawing
      * @param offset A constant pixel offset used in coordinate calculations
+     * @param allowFastMath When true, calculate using 32-bit floating point values (faster, but less accurate)
      */
-    function NumericCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset) {
+    function NumericCoordinateCalculator(webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, allowFastMath) {
         if (offset === void 0) { offset = 0; }
+        if (allowFastMath === void 0) { allowFastMath = false; }
         var _this = _super.call(this, webAssemblyContext, viewportDimension, visibleMin, visibleMax, offset, false) || this;
-        _this.nativeCalculator = new webAssemblyContext.LinearCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset);
+        _this.nativeCalculator = allowFastMath
+            ? new webAssemblyContext.LinearCoordinateCalculatorSingle(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset)
+            : new webAssemblyContext.LinearCoordinateCalculatorDouble(_this.viewportDimension, _this.visibleMin, _this.visibleMax, -1, _this.offset);
         return _this;
     }
     return NumericCoordinateCalculator;

package/Charting/Numerics/Resamplers/ExtremeResamplerHelper.d.ts

@@ -0,0 +1,54 @@
+import { IDeletable } from "../../../Core/IDeletable";
+import { IntVector, SCRTDoubleResamplerMergeIndicesParams, SCRTDoubleVector, TSciChart } from "../../../types/TSciChart";
+import { ResamplingParams } from "./ResamplingParams";
+/**
+ * Helper class for functions which optimise drawing
+ */
+export declare class ExtremeResamplerHelper implements IDeletable {
+    readonly nativeMergeIndexParams: SCRTDoubleResamplerMergeIndicesParams;
+    private readonly wasmContext;
+    private readonly nativeResampler;
+    private readonly xInput;
+    private readonly nativeArgs;
+    private readonly output;
+    private isDeleted;
+    constructor(wasmContext: TSciChart);
+    /**
+     * Calls native RequiresReduction method to calculate if resampling is needed
+     * @param rp The resampling params
+     * @param xOriginalValues XValues
+     * @param fillBasicNativeArgs Update nativeArgs if True
+     * @param updateResamplingMode Update {@link ResamplingArgs.Resampling} property if True
+     */
+    needsResampling(rp: ResamplingParams, xOriginalValues: SCRTDoubleVector, fillBasicNativeArgs?: boolean, updateResamplingMode?: boolean): boolean;
+    /**
+     * This method calls does resampling by calling the native resampling methods.
+     * It does similar things as WPF AvxExtremeResamplerDoubleDouble.ResampleInternal() method
+     * The needsResampling() method must be called before, this is done in {@link SciChartRenderer.resampleSeries}
+     * @param wasmContext The WebAssembly context
+     * @param rp The resampling parameters
+     * @param xOriginalValues The original not resampled X values
+     * @param yOriginalValues The original not resampled Y values
+     * @param indexesOut The indices output
+     * @param xResampledValuesOut The resampled X values output
+     * @param yResampledValuesOut The resampled Y values output
+     * @param fillBasicNativeArgs If set to True resets and fill nativeArgs with basic properties,
+     * you can set it to False if {@link needsResampling()} was called before this method
+     * @returns indicesVector The resampled vector of indices
+     */
+    resampleIntoPointSeries(wasmContext: TSciChart, rp: ResamplingParams, xOriginalValues: SCRTDoubleVector, yOriginalValues: SCRTDoubleVector, indexesOut: IntVector, xResampledValuesOut: SCRTDoubleVector, yResampledValuesOut: SCRTDoubleVector, fillBasicNativeArgs?: boolean): void;
+    mergeIndexes(indices: IntVector, size1: number, size2: number, mergedIndicesOut: IntVector): number;
+    copyValuesByIndexes(indices: IntVector, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, y1Values: SCRTDoubleVector, count: number, isCategoryAxis: boolean, xValuesOut: SCRTDoubleVector, yValuesOut: SCRTDoubleVector, y1ValuesOut: SCRTDoubleVector): void;
+    /** @inheritDoc */
+    delete(): void;
+    private debugParameters;
+    private debugRect;
+    private debugResamplingDataEnum;
+    private debugResamplingModeEnum;
+    private getDataDistribution;
+    private getNativeResamplingMode;
+    /**
+     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods
+     */
+    private resetAndFillBasicNativeArgs;
+}

package/Charting/Numerics/Resamplers/ExtremeResamplerHelper.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtremeResamplerHelper = void 0;
+var Deleter_1 = require("../../../Core/Deleter");
+var Guard_1 = require("../../../Core/Guard");
+var ResamplingMode_1 = require("./ResamplingMode");
+/**
+ * Helper class for functions which optimise drawing
+ */
+var ExtremeResamplerHelper = /** @class */ (function () {
+    function ExtremeResamplerHelper(wasmContext) {
+        this.isDeleted = false;
+        this.nativeMergeIndexParams = new wasmContext.SCRTDoubleResamplerMergeIndicesParams();
+        this.wasmContext = wasmContext;
+        this.nativeResampler = new this.wasmContext.SCRTDoubleResampler();
+        this.xInput = new this.wasmContext.SCRTXvaluesProvider();
+        this.nativeArgs = new this.wasmContext.ResamplingArgs();
+        this.output = new this.wasmContext.SCRTDoubleArraysXyResampleOutput();
+    }
+    /**
+     * Calls native RequiresReduction method to calculate if resampling is needed
+     * @param rp The resampling params
+     * @param xOriginalValues XValues
+     * @param fillBasicNativeArgs Update nativeArgs if True
+     * @param updateResamplingMode Update {@link ResamplingArgs.Resampling} property if True
+     */
+    ExtremeResamplerHelper.prototype.needsResampling = function (rp, xOriginalValues, fillBasicNativeArgs, updateResamplingMode) {
+        if (fillBasicNativeArgs === void 0) { fillBasicNativeArgs = true; }
+        if (updateResamplingMode === void 0) { updateResamplingMode = false; }
+        if (fillBasicNativeArgs)
+            this.resetAndFillBasicNativeArgs(rp, xOriginalValues);
+        var needsResampling = this.nativeResampler.RequiresReduction(this.nativeArgs);
+        if (updateResamplingMode && !needsResampling) {
+            this.nativeArgs.Resampling = this.getNativeResamplingMode(ResamplingMode_1.EResamplingMode.None);
+        }
+        return needsResampling;
+    };
+    /**
+     * This method calls does resampling by calling the native resampling methods.
+     * It does similar things as WPF AvxExtremeResamplerDoubleDouble.ResampleInternal() method
+     * The needsResampling() method must be called before, this is done in {@link SciChartRenderer.resampleSeries}
+     * @param wasmContext The WebAssembly context
+     * @param rp The resampling parameters
+     * @param xOriginalValues The original not resampled X values
+     * @param yOriginalValues The original not resampled Y values
+     * @param indexesOut The indices output
+     * @param xResampledValuesOut The resampled X values output
+     * @param yResampledValuesOut The resampled Y values output
+     * @param fillBasicNativeArgs If set to True resets and fill nativeArgs with basic properties,
+     * you can set it to False if {@link needsResampling()} was called before this method
+     * @returns indicesVector The resampled vector of indices
+     */
+    ExtremeResamplerHelper.prototype.resampleIntoPointSeries = function (wasmContext, rp, xOriginalValues, yOriginalValues, indexesOut, xResampledValuesOut, yResampledValuesOut, fillBasicNativeArgs) {
+        if (fillBasicNativeArgs === void 0) { fillBasicNativeArgs = true; }
+        if (this.isDeleted) {
+            throw new Error("should not call resampleIntoPointSeries() if deleted");
+        }
+        Guard_1.Guard.notNull(xOriginalValues, "xDataValues");
+        Guard_1.Guard.notNull(yOriginalValues, "yDataValues");
+        Guard_1.Guard.notNull(xOriginalValues, "xOriginalValues");
+        Guard_1.Guard.notNull(yOriginalValues, "yOriginalValues");
+        Guard_1.Guard.notNull(rp, "resamplingParams");
+        if (fillBasicNativeArgs)
+            this.resetAndFillBasicNativeArgs(rp, xOriginalValues);
+        // Set X Values
+        this.xInput.SetInput(xOriginalValues);
+        this.nativeArgs.FifoCapacity = rp.fifoCapacity;
+        this.nativeArgs.HasNaN = rp.dataHasNaN;
+        this.nativeArgs.IsFifo = rp.dataIsFifo;
+        this.nativeArgs.ResamplingPrecision = rp.precision;
+        this.nativeArgs.ZeroLineY = rp.zeroLineY;
+        this.nativeArgs.NewDataPointCount = -1;
+        if (fillBasicNativeArgs === true) {
+            this.needsResampling(rp, xOriginalValues, false, true);
+        }
+        // this.debugParameters(rp, this.nativeArgs);
+        // What does this method do???
+        var requestedSize = this.nativeResampler.UpdateIndices(indexesOut, this.xInput, yOriginalValues, this.nativeArgs.Resampling, this.nativeArgs);
+        // SC-5145 Adds +1 to be sure that reserved Capacity is not less than the actual resampled count,
+        // otherwise resampledXValues and resampledYValues will be recreated with default 0.0 values
+        xResampledValuesOut.resizeFast(requestedSize + 1);
+        yResampledValuesOut.resizeFast(requestedSize + 1);
+        this.output.Reset(xResampledValuesOut, yResampledValuesOut);
+        // Execute resampling and update indexesOut vector
+        this.nativeResampler.Execute(this.xInput, yOriginalValues, this.output, indexesOut, this.nativeArgs.Resampling, this.nativeArgs);
+        var resultCount = indexesOut.size();
+        xResampledValuesOut.resizeFast(resultCount);
+        yResampledValuesOut.resizeFast(resultCount);
+    };
+    ExtremeResamplerHelper.prototype.mergeIndexes = function (indices, size1, size2, mergedIndicesOut) {
+        return this.nativeResampler.MergeIndices(indices, size1, size2, mergedIndicesOut);
+    };
+    ExtremeResamplerHelper.prototype.copyValuesByIndexes = function (indices, xValues, yValues, y1Values, count, isCategoryAxis, xValuesOut, yValuesOut, y1ValuesOut) {
+        var mp = this.nativeMergeIndexParams;
+        mp.SetIndices(indices);
+        this.xInput.SetInput(xValues);
+        mp.SetXInput(this.xInput);
+        mp.SetYInput(yValues);
+        mp.SetY1Input(y1Values);
+        mp.count = count;
+        mp.isCategoryData = isCategoryAxis;
+        mp.SetXOut(xValuesOut);
+        mp.SetYOut(yValuesOut);
+        mp.SetY1Out(y1ValuesOut);
+        this.nativeResampler.CopyValuesByIndices(mp);
+    };
+    /** @inheritDoc */
+    ExtremeResamplerHelper.prototype.delete = function () {
+        if (!this.isDeleted) {
+            (0, Deleter_1.deleteSafe)(this.nativeResampler);
+            (0, Deleter_1.deleteSafe)(this.xInput);
+            (0, Deleter_1.deleteSafe)(this.nativeArgs);
+            (0, Deleter_1.deleteSafe)(this.output);
+            (0, Deleter_1.deleteSafe)(this.nativeMergeIndexParams);
+            this.isDeleted = true;
+        }
+    };
+    ExtremeResamplerHelper.prototype.debugParameters = function (rp, nativeArgs) {
+        console.log(31415);
+        console.log("ResamplingParams:");
+        console.log(".. zeroLineY: ".concat(rp.zeroLineY));
+        console.log(".. resamplingPrecision: ".concat(rp.precision));
+        console.log(".. xVisibleRange: ".concat(rp.xVisibleRange));
+        console.log(".. indicesRange: ".concat(rp.indexesRange));
+        console.log(".. viewportRect: ".concat(this.debugRect(rp.viewportRect)));
+        console.log(".. isCategoryAxis: ".concat(rp.isCategoryAxis));
+        console.log(".. isXAxisAutoRanged: ".concat(rp.isXAxisAutoRanged));
+        console.log(".. resamplingMode: ".concat(rp.resamplingMode));
+        console.log(".. renderableSeriesHash: ".concat(rp.renderableSeriesHash));
+        console.log(".. enableExperimentalResampling: ".concat(rp.enableExperimentalResampling));
+        console.log(".. dataHasNan: ".concat(rp.dataHasNaN));
+        console.log(".. dataIsFifo: ".concat(rp.dataIsFifo));
+        console.log(".. fifoCapacity: ".concat(rp.fifoCapacity));
+        console.log(".. dataEvenlySpaced: ".concat(rp.dataEvenlySpaced));
+        console.log("native Resampling Args:");
+        console.log(".. ResamplingData: ".concat(this.debugResamplingDataEnum(nativeArgs.Data)));
+        console.log(".. StartIndex: ".concat(nativeArgs.StartIndex));
+        console.log(".. EndIndex: ".concat(nativeArgs.EndIndex));
+        console.log(".. FifoCapacity: ".concat(nativeArgs.FifoCapacity));
+        console.log(".. HasNaN: ".concat(nativeArgs.HasNaN));
+        console.log(".. IsFifo: ".concat(nativeArgs.IsFifo));
+        console.log(".. MaxXInclusive: ".concat(nativeArgs.MaxXInclusive));
+        console.log(".. MinXInclusive: ".concat(nativeArgs.MinXInclusive));
+        console.log(".. ResamplingMode: ".concat(this.debugResamplingModeEnum(nativeArgs.Resampling)));
+        console.log(".. ResamplingPrecision: ".concat(nativeArgs.ResamplingPrecision));
+        console.log(".. ViewportWidth: ".concat(nativeArgs.ViewportWidth));
+        console.log(".. ZeroLineY: ".concat(nativeArgs.ZeroLineY));
+        console.log(".. NewDataPointCount: ".concat(nativeArgs.NewDataPointCount));
+        console.log(".. InputBaseIndex: ".concat(nativeArgs.InputBaseIndex));
+    };
+    ExtremeResamplerHelper.prototype.debugRect = function (rect) {
+        return "X ".concat(rect.x, " Y ").concat(rect.y, " Width ").concat(rect.width, " Height ").concat(rect.height);
+    };
+    ExtremeResamplerHelper.prototype.debugResamplingDataEnum = function (resamplingData) {
+        return resamplingData === this.wasmContext.ResamplingData.LinearData
+            ? "LinearData"
+            : resamplingData === this.wasmContext.ResamplingData.CategoryData
+                ? "CategoryData"
+                : resamplingData === this.wasmContext.ResamplingData.UnsortedData
+                    ? "UnsortedData"
+                    : resamplingData === this.wasmContext.ResamplingData.UnevenlySpacedData
+                        ? "UnevenlySpacedData"
+                        : "Unknown";
+    };
+    ExtremeResamplerHelper.prototype.debugResamplingModeEnum = function (resamplingMode) {
+        return resamplingMode === this.wasmContext.ResamplingMode.MinMax
+            ? "MinMax"
+            : resamplingMode === this.wasmContext.ResamplingMode.Auto
+                ? "Auto"
+                : "Unknown";
+    };
+    ExtremeResamplerHelper.prototype.getDataDistribution = function (dataEvenlySpaced, isCategoryAxis) {
+        if (isCategoryAxis) {
+            return this.wasmContext.ResamplingData.CategoryData;
+        }
+        return dataEvenlySpaced
+            ? this.wasmContext.ResamplingData.LinearData
+            : this.wasmContext.ResamplingData.UnevenlySpacedData;
+    };
+    // A different requireReduction method
+    // private requireReduction(resamplingMode: EResamplingMode, indicesRange: NumberRange, viewportWidth: number) {
+    //     const setLength = indicesRange.max - indicesRange.min + 1;
+    //     const resampledLength = 4 * viewportWidth;
+    //
+    //     return resamplingMode !== EResamplingMode.None && setLength > resampledLength;
+    // }
+    ExtremeResamplerHelper.prototype.getNativeResamplingMode = function (resamplingMode) {
+        switch (resamplingMode) {
+            case ResamplingMode_1.EResamplingMode.Auto:
+                return this.wasmContext.ResamplingMode.Auto;
+            case ResamplingMode_1.EResamplingMode.Max:
+                return this.wasmContext.ResamplingMode.Max;
+            case ResamplingMode_1.EResamplingMode.Mid:
+                return this.wasmContext.ResamplingMode.Mid;
+            case ResamplingMode_1.EResamplingMode.Min:
+                return this.wasmContext.ResamplingMode.Min;
+            case ResamplingMode_1.EResamplingMode.MinMax:
+                return this.wasmContext.ResamplingMode.MinMax;
+            case ResamplingMode_1.EResamplingMode.MinOrMax:
+                return this.wasmContext.ResamplingMode.MinOrMax;
+            case ResamplingMode_1.EResamplingMode.None:
+                return this.wasmContext.ResamplingMode.None;
+            default:
+                throw new Error("Unknown resamplingMode ".concat(resamplingMode));
+        }
+    };
+    /**
+     * Fills basic native args needed for {@link needsResampling()} and {@link resampleIntoPointSeries} methods
+     */
+    ExtremeResamplerHelper.prototype.resetAndFillBasicNativeArgs = function (rp, xOriginalValues) {
+        this.nativeArgs.Reset();
+        this.nativeArgs.Data = this.getDataDistribution(rp.dataEvenlySpaced, rp.isCategoryAxis);
+        this.nativeArgs.StartIndex = rp.indexesRange.min;
+        this.nativeArgs.EndIndex = rp.indexesRange.max;
+        this.nativeArgs.MaxXInclusive = rp.xVisibleRange.max;
+        this.nativeArgs.MinXInclusive = rp.xVisibleRange.min;
+        this.nativeArgs.Resampling = this.getNativeResamplingMode(rp.resamplingMode);
+        this.nativeArgs.ViewportWidth = rp.viewportRect.width;
+        if (rp.isCategoryAxis) {
+            this.nativeArgs.MinXInclusive = rp.indexesRange.min;
+            this.nativeArgs.MaxXInclusive = rp.indexesRange.max;
+        }
+        else {
+            var firstPoint = xOriginalValues.get(rp.indexesRange.min);
+            var lastPoint = xOriginalValues.get(rp.indexesRange.max);
+            this.nativeArgs.MinXInclusive = Math.max(firstPoint, rp.xVisibleRange.min);
+            this.nativeArgs.MaxXInclusive = Math.min(lastPoint, rp.xVisibleRange.max);
+        }
+    };
+    return ExtremeResamplerHelper;
+}());
+exports.ExtremeResamplerHelper = ExtremeResamplerHelper;