scichart 2.0.2228 → 2.1.2273

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, y1Offset?: number): 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,234 @@
+"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, y1Offset) {
+        if (y1Offset === void 0) { y1Offset = 0; }
+        var mp = this.nativeMergeIndexParams;
+        mp.SetIndices(indices);
+        this.xInput.SetInput(xValues);
+        mp.SetXInput(this.xInput);
+        mp.SetYInput(yValues);
+        mp.SetY1Input(y1Values);
+        mp.SetY1Offset(y1Offset);
+        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;
+}

package/Charting/Numerics/Resamplers/ResamplingParams.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResamplingParams = void 0;
+var AutoRange_1 = require("../../../types/AutoRange");
+var ResamplingParams = /** @class */ (function () {
+    function ResamplingParams(seriesViewRect, rs, xAxis) {
+        this.zeroLineY = 0;
+        this.precision = 0;
+        this.enableExperimentalResampling = false;
+        this.dataIsFifo = false;
+        this.fifoCapacity = 0;
+        this.viewportRect = seriesViewRect;
+        if (rs) {
+            var dataSeries = rs.dataSeries;
+            this.resamplingMode = rs.resamplingMode;
+            this.precision = rs.resamplingPrecision;
+            if (xAxis) {
+                this.indexesRange = rs.getIndicesRange(xAxis.visibleRange, xAxis.isCategoryAxis);
+                // console.log("visible range", xAxis.visibleRange.min, xAxis.visibleRange.max);
+                // console.log("indexes range", this.indexesRange.min, this.indexesRange.max);
+                this.isCategoryAxis = xAxis.isCategoryAxis;
+                this.isXAxisAutoRanged = xAxis.autoRange === AutoRange_1.EAutoRange.Always;
+                this.xVisibleRange = xAxis.visibleRange;
+            }
+            if (dataSeries) {
+                this.dataHasNaN = dataSeries === null || dataSeries === void 0 ? void 0 : dataSeries.dataDistributionCalculator.containsNaN;
+                this.dataEvenlySpaced = dataSeries === null || dataSeries === void 0 ? void 0 : dataSeries.isEvenlySpaced;
+            }
+        }
+    }
+    ResamplingParams.prototype.clone = function (options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var rp = new ResamplingParams(undefined, undefined, undefined);
+        rp.zeroLineY = (_a = options === null || options === void 0 ? void 0 : options.zeroLineY) !== null && _a !== void 0 ? _a : this.zeroLineY;
+        rp.precision = (_b = options === null || options === void 0 ? void 0 : options.precision) !== null && _b !== void 0 ? _b : this.precision;
+        rp.xVisibleRange = (_c = options === null || options === void 0 ? void 0 : options.xVisibleRange) !== null && _c !== void 0 ? _c : this.xVisibleRange;
+        rp.indexesRange = (_d = options === null || options === void 0 ? void 0 : options.indicesRange) !== null && _d !== void 0 ? _d : this.indexesRange;
+        rp.viewportRect = (_e = options === null || options === void 0 ? void 0 : options.viewportRect) !== null && _e !== void 0 ? _e : this.viewportRect;
+        rp.isCategoryAxis = (_f = options === null || options === void 0 ? void 0 : options.isCategoryAxis) !== null && _f !== void 0 ? _f : this.isCategoryAxis;
+        rp.isXAxisAutoRanged = (_g = options === null || options === void 0 ? void 0 : options.isXAxisAutoRanged) !== null && _g !== void 0 ? _g : this.isXAxisAutoRanged;
+        rp.resamplingMode = (_h = options === null || options === void 0 ? void 0 : options.resamplingMode) !== null && _h !== void 0 ? _h : this.resamplingMode;
+        rp.renderableSeriesHash = (_j = options === null || options === void 0 ? void 0 : options.renderableSeriesHash) !== null && _j !== void 0 ? _j : this.renderableSeriesHash;
+        rp.enableExperimentalResampling = (_k = options === null || options === void 0 ? void 0 : options.enableExperimentalResampling) !== null && _k !== void 0 ? _k : this.enableExperimentalResampling;
+        rp.dataHasNaN = (_l = options === null || options === void 0 ? void 0 : options.dataHasNaN) !== null && _l !== void 0 ? _l : this.dataHasNaN;
+        rp.dataIsFifo = (_m = options === null || options === void 0 ? void 0 : options.dataIsFifo) !== null && _m !== void 0 ? _m : this.dataIsFifo;
+        rp.fifoCapacity = (_o = options === null || options === void 0 ? void 0 : options.fifoCapacity) !== null && _o !== void 0 ? _o : this.fifoCapacity;
+        rp.dataEvenlySpaced = (_p = options === null || options === void 0 ? void 0 : options.dataEvenlySpaced) !== null && _p !== void 0 ? _p : this.dataEvenlySpaced;
+        return rp;
+    };
+    return ResamplingParams;
+}());
+exports.ResamplingParams = ResamplingParams;

package/Charting/Services/RenderPassData.d.ts

@@ -1,4 +1,5 @@
 import { NumberRange } from "../../Core/NumberRange";
+import { IPointSeries } from "../Model/PointSeries/IPointSeries";
 import { CoordinateCalculatorBase } from "../Numerics/CoordinateCalculators/CoordinateCalculatorBase";
 /**
  * @summary RenderPassData contains properties which are passed to {@link BaseRenderableSeries} at the time of drawing
@@ -8,6 +9,8 @@ export declare class RenderPassData {
     readonly xCoordinateCalculator: CoordinateCalculatorBase;
     readonly yCoordinateCalculator: CoordinateCalculatorBase;
     readonly isVerticalChart: boolean;
+    readonly pointSeries?: IPointSeries;
+    readonly resamplingHash?: number;
     /**
      * Creates an instance of RenderPassData
      * @param indexRange The min and max index to data-range currently visible on the {@link SciChartSurface}
@@ -16,6 +19,8 @@ export declare class RenderPassData {
      * @param yCoordinateCalculator The YAxis {@link CoordinateCalculatorBase | Coordinate Calculator},
      * used to transform between pixel and data-coordinates
      * @param isVerticalChart A flag indicating if the chart is currently vertically arranged (XAxis on the left, YAxis on the top/bottom)
+     * @param pointSeries The point series
+     * @param resamplingHash The resampling hash value, used for caching
      */
-    constructor(indexRange: NumberRange, xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, isVerticalChart: boolean);
+    constructor(indexRange: NumberRange, xCoordinateCalculator: CoordinateCalculatorBase, yCoordinateCalculator: CoordinateCalculatorBase, isVerticalChart: boolean, pointSeries?: IPointSeries, resamplingHash?: number);
 }

package/Charting/Services/RenderPassData.js

@@ -13,12 +13,16 @@ var RenderPassData = /** @class */ (function () {
      * @param yCoordinateCalculator The YAxis {@link CoordinateCalculatorBase | Coordinate Calculator},
      * used to transform between pixel and data-coordinates
      * @param isVerticalChart A flag indicating if the chart is currently vertically arranged (XAxis on the left, YAxis on the top/bottom)
+     * @param pointSeries The point series
+     * @param resamplingHash The resampling hash value, used for caching
      */
-    function RenderPassData(indexRange, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart) {
+    function RenderPassData(indexRange, xCoordinateCalculator, yCoordinateCalculator, isVerticalChart, pointSeries, resamplingHash) {
         this.indexRange = indexRange;
         this.xCoordinateCalculator = xCoordinateCalculator;
         this.yCoordinateCalculator = yCoordinateCalculator;
         this.isVerticalChart = isVerticalChart;
+        this.pointSeries = pointSeries;
+        this.resamplingHash = resamplingHash;
     }
     return RenderPassData;
 }());

package/Charting/Services/RenderPassInfo.d.ts

@@ -0,0 +1,18 @@
+import { NumberRange } from "../../Core/NumberRange";
+import { Rect } from "../../Core/Rect";
+import { IPointSeries } from "../Model/PointSeries/IPointSeries";
+import { IRenderableSeries } from "../Visuals/RenderableSeries/IRenderableSeries";
+export declare type TSeriesRenderPassInfo = {
+    pointSeries: IPointSeries;
+    renderableSeries: IRenderableSeries;
+    indicesRange: NumberRange;
+    resamplingHash: number;
+};
+export declare class RenderPassInfo {
+    pointSeriesArray: IPointSeries[];
+    renderableSeriesArray: IRenderableSeries[];
+    indicesRanges: NumberRange[];
+    resamplingHashes: number[];
+    seriesViewRect: Rect;
+    constructor(seriesCount: number, seriesViewRect: Rect);
+}

package/Charting/Services/RenderPassInfo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderPassInfo = void 0;
+var RenderPassInfo = /** @class */ (function () {
+    function RenderPassInfo(seriesCount, seriesViewRect) {
+        this.pointSeriesArray = [];
+        this.renderableSeriesArray = [];
+        this.indicesRanges = [];
+        this.resamplingHashes = [];
+        this.seriesViewRect = seriesViewRect;
+    }
+    return RenderPassInfo;
+}());
+exports.RenderPassInfo = RenderPassInfo;

package/Charting/Services/SciChartRenderer.d.ts

@@ -1,9 +1,21 @@
+import { Rect } from "../../Core/Rect";
 import { WebGlRenderContext2D } from "../Drawing/WebGlRenderContext2D";
+import { AxisBase2D } from "../Visuals/Axis/AxisBase2D";
+import { IRenderableSeries } from "../Visuals/RenderableSeries/IRenderableSeries";
 import { SciChartSurface } from "../Visuals/SciChartSurface";
+import { TSeriesRenderPassInfo } from "./RenderPassInfo";
 /**
  * A class used internally in SciChart to perform layout, arrangement, data-preparation and rendering on the Cartesian 2D {@link SciChartSurface}
  */
 export declare class SciChartRenderer {
+    /**
+     * Used internally
+     * @param xAxis
+     * @param rs
+     * @param seriesViewRect
+     */
+    static resampleSeries(xAxis: AxisBase2D, rs: IRenderableSeries, seriesViewRect: Rect): TSeriesRenderPassInfo;
+    private static calculateResamplingHash;
     private sciChartSurface;
     private previousTime;
     /**
@@ -20,7 +32,8 @@ export declare class SciChartRenderer {
     private drawSvgAnnotations;
     private validate;
     private updateSvgCanvasSize;
-    private prepareRenderData;
+    private prepareAxesRenderData;
+    private prepareSeriesRenderData;
     private drawAxes;
     private drawSeries;
     private drawDebugAxes;