scichart 2.0.2194 → 2.1.0-beta.40

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);
@@ -98,9 +100,9 @@ var XyzDataSeries = /** @class */ (function (_super) {
      */
     XyzDataSeries.prototype.appendRange = function (xValues, yValues, zValues, metadata) {
         if (!this.getIsDeleted()) {
-            Guard_1.Guard.isTrue(Array.isArray(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
-            Guard_1.Guard.isTrue(Array.isArray(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
-            Guard_1.Guard.isTrue(Array.isArray(zValues) || (0, NumberArray_1.isTypedArray)(zValues), "zValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(zValues) || (0, NumberArray_1.isTypedArray)(zValues), "zValues must be an array of numbers");
             Guard_1.Guard.arraysSameLengthArr([
                 { arg: xValues, name: "xValues" },
                 { arg: yValues, name: "yValues" },
@@ -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);
@@ -193,9 +201,9 @@ var XyzDataSeries = /** @class */ (function (_super) {
      */
     XyzDataSeries.prototype.insertRange = function (startIndex, xValues, yValues, zValues, metadata) {
         if (!this.getIsDeleted()) {
-            Guard_1.Guard.isTrue(Array.isArray(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
-            Guard_1.Guard.isTrue(Array.isArray(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
-            Guard_1.Guard.isTrue(Array.isArray(zValues) || (0, NumberArray_1.isTypedArray)(zValues), "zValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(xValues) || (0, NumberArray_1.isTypedArray)(xValues), "xValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(yValues) || (0, NumberArray_1.isTypedArray)(yValues), "yValues must be an array of numbers");
+            Guard_1.Guard.isTrue((0, NumberArray_1.isNumberArray)(zValues) || (0, NumberArray_1.isTypedArray)(zValues), "zValues must be an array of numbers");
             this.validateIndex(startIndex, "Start index is out of range");
             Guard_1.Guard.arraysSameLengthArr([
                 { arg: xValues, name: "xValues" },
@@ -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;

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

@@ -0,0 +1,37 @@
+export declare enum EResamplingMode {
+    /**
+     * Do not use resampling when redrawing a series
+     */
+    None = "None",
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the min-max of oversampled data.
+     * This results in the most visually accurate resampling, with the most performan
+     */
+    MinMax = "MinMax",
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the median point of oversampled data
+     */
+    Mid = "Mid",
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the maximum point of oversampled data
+     */
+    Max = "Max",
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the minimum point of oversampled data
+     */
+    Min = "Min",
+    /**
+     * Does not assume Evenly-spaced data (TimeSeries). Resample by taking the min-max of oversampled data.
+     * This results in the most visually accurate resampling, with the most performant rendering
+     */
+    MinMaxWithUnevenSpacing = "MinMaxWithUnevenSpacing",
+    /**
+     * Auto-detect the most suitable resampling algorithm (Fastest, plus most accurate) for the type of data appended
+     */
+    Auto = "Auto",
+    /**
+     * EXPERIMENTAL! Assumes Evenly-spaced data (TimeSeries).
+     * Resample by taking the Min, or the Max point of oversampled data. Outputs Min and Max when points in the resampling bucket span zero
+     */
+    MinOrMax = "MinOrMax"
+}

package/Charting/Numerics/Resamplers/ResamplingMode.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EResamplingMode = void 0;
+var EResamplingMode;
+(function (EResamplingMode) {
+    /**
+     * Do not use resampling when redrawing a series
+     */
+    EResamplingMode["None"] = "None";
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the min-max of oversampled data.
+     * This results in the most visually accurate resampling, with the most performan
+     */
+    EResamplingMode["MinMax"] = "MinMax";
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the median point of oversampled data
+     */
+    EResamplingMode["Mid"] = "Mid";
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the maximum point of oversampled data
+     */
+    EResamplingMode["Max"] = "Max";
+    /**
+     * Assumes Evenly-spaced data (TimeSeries). Resample by taking the minimum point of oversampled data
+     */
+    EResamplingMode["Min"] = "Min";
+    /**
+     * Does not assume Evenly-spaced data (TimeSeries). Resample by taking the min-max of oversampled data.
+     * This results in the most visually accurate resampling, with the most performant rendering
+     */
+    EResamplingMode["MinMaxWithUnevenSpacing"] = "MinMaxWithUnevenSpacing";
+    /**
+     * Auto-detect the most suitable resampling algorithm (Fastest, plus most accurate) for the type of data appended
+     */
+    EResamplingMode["Auto"] = "Auto";
+    /**
+     * EXPERIMENTAL! Assumes Evenly-spaced data (TimeSeries).
+     * Resample by taking the Min, or the Max point of oversampled data. Outputs Min and Max when points in the resampling bucket span zero
+     */
+    EResamplingMode["MinOrMax"] = "MinOrMax";
+})(EResamplingMode = exports.EResamplingMode || (exports.EResamplingMode = {}));

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

@@ -0,0 +1,39 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { Rect } from "../../../Core/Rect";
+import { AxisBase2D } from "../../Visuals/Axis/AxisBase2D";
+import { IRenderableSeries } from "../../Visuals/RenderableSeries/IRenderableSeries";
+import { EResamplingMode } from "./ResamplingMode";
+export interface IResamplingParamsCloneOptions {
+    zeroLineY?: number;
+    precision?: number;
+    xVisibleRange?: NumberRange;
+    indicesRange?: NumberRange;
+    viewportRect?: Rect;
+    isCategoryAxis?: boolean;
+    isXAxisAutoRanged?: boolean;
+    resamplingMode?: EResamplingMode;
+    renderableSeriesHash?: number;
+    enableExperimentalResampling?: boolean;
+    dataHasNaN?: boolean;
+    dataIsFifo?: boolean;
+    fifoCapacity?: number;
+    dataEvenlySpaced?: boolean;
+}
+export declare class ResamplingParams {
+    zeroLineY: number;
+    precision: number;
+    xVisibleRange: NumberRange;
+    indexesRange: NumberRange;
+    viewportRect: Rect;
+    isCategoryAxis: boolean;
+    isXAxisAutoRanged: boolean;
+    resamplingMode: EResamplingMode;
+    renderableSeriesHash: number;
+    enableExperimentalResampling: boolean;
+    dataHasNaN: boolean;
+    dataIsFifo: boolean;
+    fifoCapacity: number;
+    dataEvenlySpaced: boolean;
+    constructor(seriesViewRect: Rect, rs: IRenderableSeries, xAxis: AxisBase2D);
+    clone(options: IResamplingParamsCloneOptions): ResamplingParams;
+}