scichart 3.1.346 → 3.2.0-beta

package/Charting/Visuals/RenderableSeries/DrawingProviders/NonUniformHeatmapDrawingProvider.js

@@ -30,13 +30,12 @@ exports.NonUniformHeatmapDrawingProvider = void 0;
 var Deleter_1 = require("../../../../Core/Deleter");
 var NumberRange_1 = require("../../../../Core/NumberRange");
 var Rect_1 = require("../../../../Core/Rect");
-var colorUtil_1 = require("../../../../utils/colorUtil");
 var memoize_1 = require("../../../../utils/memoize");
-var parseColor_1 = require("../../../../utils/parseColor");
 var TextureCache_1 = require("../../../Drawing/TextureCache");
 var BaseHeatmapRenderableSeries_1 = require("../BaseHeatmapRenderableSeries");
 var constants_1 = require("../constants");
 var BaseSeriesDrawingProvider_1 = require("./BaseSeriesDrawingProvider");
+var HeatmapHelpers_1 = require("./HeatmapHelpers");
 // TODO figure out if other value is needed
 var precision = 100;
 /**
@@ -79,7 +78,7 @@ var NonUniformHeatmapDrawingProvider = /** @class */ (function (_super) {
             propertyName === constants_1.PROPERTY.OPACITY;
         if (recreateGradientColorScale) {
             // TODO check case when colormap is passed via setter
-            this.colorGradientScale = createColorMap(this.parentSeries.colorMap.gradientStops, precision);
+            this.colorGradientScale = (0, HeatmapHelpers_1.createColorMap)(this.parentSeries.colorMap.gradientStops, precision);
         }
     };
     /**
@@ -202,7 +201,7 @@ var NonUniformHeatmapDrawingProvider = /** @class */ (function (_super) {
         var visibleTextureHeight = Math.ceil(Math.abs(yMinCoordinate - yMaxCoordinate));
         var heatmapRect = new Rect_1.Rect(heatmapStartX, heatmapStartY, heatmapWidth, heatmapHeight);
         // calculates cell offsets in pixels from cell sizes
-        var _a = calculateOffsets(heatmapRect, isVerticalChart, xCellSizes, yCellSizes, horStartInd, horCellCount, horInc, vertStartInd, vertCellCount, vertInc, seriesViewRect), horCellOffsets = _a.horCellOffsets, vertCellOffsets = _a.vertCellOffsets;
+        var _a = (0, HeatmapHelpers_1.calculateOffsets)(heatmapRect, isVerticalChart, xCellSizes, yCellSizes, horStartInd, horCellCount, horInc, vertStartInd, vertCellCount, vertInc, seriesViewRect), horCellOffsets = _a.horCellOffsets, vertCellOffsets = _a.vertCellOffsets;
         var texture = this.calculateHeatmapTexture({
             xStartInd: horStartInd,
             textureWidth: visibleTextureWidth,
@@ -257,237 +256,13 @@ var NonUniformHeatmapDrawingProvider = /** @class */ (function (_super) {
                     areArraysEqual(currentHorCellOffsets, prevHorCellOffsets) &&
                     areArraysEqual(currVertCellOffsets, prevVertCellOffsets));
             };
-            this.getMemoizedHeatmapTexture = (0, memoize_1.memoize)(calculateHeatmapTexture, customCompare);
+            this.getMemoizedHeatmapTexture = (0, memoize_1.memoize)(HeatmapHelpers_1.calculateHeatmapTexture, customCompare);
         }
         var areArraysEqual = function (arr1, arr2) {
             return !arr1.some(function (value, index) { return value !== arr2[index]; });
         };
-        return this.getMemoizedHeatmapTexture(colorDataParams, this.colorDataVector, this.heatTextureCache);
+        return this.getMemoizedHeatmapTexture(colorDataParams, this.colorDataVector, this.heatTextureCache, precision);
     };
     return NonUniformHeatmapDrawingProvider;
 }(BaseSeriesDrawingProvider_1.BaseSeriesDrawingProvider));
 exports.NonUniformHeatmapDrawingProvider = NonUniformHeatmapDrawingProvider;
-var getColorDataForTexture = function (params, _colorData) {
-    var xStartInd = params.xStartInd, textureWidth = params.textureWidth, xInc = params.xInc, yStartInd = params.yStartInd, textureHeight = params.textureHeight, yInc = params.yInc, zValues = params.zValues, webAssemblyContext = params.webAssemblyContext, colorMap = params.colorMap, opacity = params.opacity, horCellCount = params.horCellCount, vertCellCount = params.vertCellCount, horCellOffsets = params.horCellOffsets, vertCellOffsets = params.vertCellOffsets, colorMin = params.colorMin, colorMax = params.colorMax, arrayWidth = params.arrayWidth, arrayHeight = params.arrayHeight, fillValuesOutOfRange = params.fillValuesOutOfRange;
-    // const _colorData = new webAssemblyContext.UIntVector();
-    _colorData.resize(textureWidth * textureHeight, 0);
-    // const _colorData = Array.from(Array(textureWidth * textureHeight));
-    var yOffsetInd = 0;
-    var yCellEnd = vertCellOffsets[yOffsetInd];
-    var cachedColors = new Array(horCellCount);
-    var hasCachedColors = false;
-    var xCellIndex = xStartInd;
-    var yCellIndex = yStartInd;
-    var color;
-    for (var y = 0; y < textureHeight; y++) {
-        var xOffsetInd = 0;
-        var xCellEnd = horCellOffsets[xOffsetInd];
-        if (y > yCellEnd) {
-            // New cell - need to refill the cache
-            hasCachedColors = false;
-            // Get the end coord of the next cell and a color for it
-            yOffsetInd++;
-            yCellEnd = vertCellOffsets[yOffsetInd];
-            // If yCellEnd falls inside a pixel, reiterate and get the next color
-            var yDiff = y - yCellEnd;
-            if (yDiff > Number.EPSILON && Math.floor(yCellEnd) + 1 === y) {
-                y--;
-                continue;
-            }
-        }
-        if (hasCachedColors) {
-            // Get color cached on previous iteration
-            color = cachedColors[xOffsetInd];
-        }
-        else {
-            xCellIndex = xStartInd + xOffsetInd * xInc;
-            yCellIndex = yStartInd + yOffsetInd * yInc;
-            color = getColor(yCellIndex, xCellIndex, colorMap, opacity, zValues, webAssemblyContext, colorMin, colorMax, arrayWidth, arrayHeight, fillValuesOutOfRange);
-            // New cell - refill the cache
-            cachedColors[xOffsetInd] = color;
-        }
-        for (var x = 0; x < textureWidth; x++) {
-            if (x > xCellEnd) {
-                // Get the end coord of the next cell and a color for it
-                xOffsetInd++;
-                xCellEnd = horCellOffsets[xOffsetInd];
-                // If xCellEnd falls inside a pixel, reiterate and get the next color
-                var xDiff = x - xCellEnd;
-                if (xDiff > Number.EPSILON && Math.floor(xCellEnd) + 1 === x) {
-                    x--;
-                    continue;
-                }
-                if (hasCachedColors) {
-                    // Get color cached on previous iteration
-                    color = cachedColors[xOffsetInd];
-                }
-                else {
-                    xCellIndex = xStartInd + xOffsetInd * xInc;
-                    color = getColor(yCellIndex, xCellIndex, colorMap, opacity, zValues, webAssemblyContext, colorMin, colorMax, arrayWidth, arrayHeight, fillValuesOutOfRange);
-                    cachedColors[xOffsetInd] = color;
-                }
-            }
-            // Fill a texture pixel
-            // _colorData[y * textureWidth + x] = color;
-            _colorData.set(y * textureWidth + x, color);
-        }
-        hasCachedColors = true;
-    }
-    return _colorData;
-};
-var getColor = function (yIndex, xIndex, colorPalette, opacity, 
-// zValues: SCRTDoubleVector,
-zValues, webAssemblyContext, colorMin, colorMax, arrayWidth, arrayHeight, fillValuesOutOfRange) {
-    // TODO is this check needed?
-    if (yIndex >= arrayHeight || xIndex >= arrayWidth) {
-        // transparent
-        return 0;
-    }
-    // const zValue = zValues.get(yIndex * arrayWidth + xIndex);
-    var zValue = zValues[yIndex][xIndex];
-    var cellColor = getCellColor(zValue, colorPalette, colorMin, colorMax, fillValuesOutOfRange, webAssemblyContext);
-    return (0, colorUtil_1.uintArgbColorMultiplyOpacity)(cellColor, opacity);
-};
-/** @ignore */
-var getCellColor = function (value, _colorMap, colorMin, colorMax, fillValuesOutOfRange, webAssemblyContext) {
-    if (isNaN(value)) {
-        // transparent
-        return 0;
-    }
-    // comment from the original C# code
-    // TODO move this to DataSeries.GetZAsDoubles(min, max) to avoid it here
-    if (fillValuesOutOfRange) {
-        // Clip to ColorMap.Min, Max
-        value = value < colorMin ? colorMin : value;
-        value = value > colorMax ? colorMax : value;
-    }
-    else if (value < colorMin || value > colorMax) {
-        // transparent
-        return 0;
-    }
-    var _scaleFactor = (precision - 1) / Math.abs(colorMax - colorMin);
-    var colorMapValue = (value - colorMin) * _scaleFactor;
-    // Round to the nearest integer
-    var colorIndex = Math.floor(colorMapValue + Math.sign(value) * 0.5);
-    colorIndex = webAssemblyContext.NumberUtil.Constrain(colorIndex, 0, _colorMap.length - 1);
-    return _colorMap[colorIndex];
-};
-// TODO configure precision
-var createColorMap = function (gradientStops, precision) {
-    var colorMap = Array.from(Array(precision));
-    var count = gradientStops.length;
-    var first = gradientStops[0].offset;
-    var last = gradientStops[gradientStops.length - 1].offset;
-    var diff = last - first;
-    var change = diff / (precision - 1);
-    // let prevColor = ApplyOpacity(gradientStops[0].color, _opacity);
-    var prevColor = gradientStops[0].color;
-    var prevOffset = gradientStops[0].offset;
-    var nextColor = prevColor;
-    var nextOffset = prevOffset;
-    if (count > 1) {
-        // nextColor = ApplyOpacity(gradientStops[1].color, _opacity);
-        nextColor = gradientStops[1].color;
-        nextOffset = gradientStops[1].offset;
-    }
-    diff = nextOffset - prevOffset;
-    var offsetInd = 0;
-    for (var i = 0; i < precision; ++i) {
-        var offset = first + i * change;
-        if (offset >= nextOffset) {
-            offsetInd++;
-            prevOffset = nextOffset;
-            prevColor = nextColor;
-            if (offsetInd + 1 < count) {
-                // nextColor = ApplyOpacity(gradientStops[offsetInd + 1].color, _opacity);
-                nextColor = gradientStops[offsetInd + 1].color;
-                nextOffset = gradientStops[offsetInd + 1].offset;
-            }
-            diff = nextOffset - prevOffset;
-        }
-        var color = void 0;
-        if (prevColor === nextColor || diff <= Number.EPSILON) {
-            color = Number.parseInt((0, parseColor_1.parseColorToHexStringArgb)(nextColor), 16);
-        }
-        else {
-            var coef = (offset - prevOffset) / diff;
-            color = getInterpolatedColor(prevColor, nextColor, coef);
-        }
-        colorMap[i] = color;
-    }
-    return colorMap;
-};
-var getInterpolatedColor = function (htmlColor1, htmlColor2, coef) {
-    var color1 = (0, parseColor_1.parseColorToTArgb)(htmlColor1);
-    var color2 = (0, parseColor_1.parseColorToTArgb)(htmlColor2);
-    var a1 = color1.opacity;
-    var a2 = color2.opacity;
-    var r1 = color1.red;
-    var r2 = color2.red;
-    var g1 = color1.green;
-    var g2 = color2.green;
-    var b1 = color1.blue;
-    var b2 = color2.blue;
-    var r = r1 + Math.floor((r2 - r1) * coef);
-    var g = g1 + Math.floor((g2 - g1) * coef);
-    var b = b1 + Math.floor((b2 - b1) * coef);
-    var a = a1 + Math.floor((a2 - a1) * coef);
-    return Number.parseInt("0x" + (0, parseColor_1.toHex)(a) + (0, parseColor_1.toHex)(r) + (0, parseColor_1.toHex)(g) + (0, parseColor_1.toHex)(b), 16);
-    // return (a << 24) | (r << 16) | (g << 8) | b;
-};
-var calculateOffsets = function (heatmapRect, isVerticalChart, xCellSizes, yCellSizes, horStartInd, horCellCount, horInc, vertStartInd, vertCellCount, vertInc, seriesViewRect) {
-    // TODO can be optimized - no need to recalculate these offsets at every redraw
-    // TODO can be optimized for large heatmaps - skip cells that
-    // falls within a single pixel & count them for the iteration in ComputeColorMap()
-    // Find heatmap cells positions
-    var offsetX = heatmapRect.left < 0 ? -heatmapRect.left : 0;
-    var offsetY = heatmapRect.top < 0 ? -heatmapRect.top : 0;
-    if (isVerticalChart) {
-        // consider that heatmap texture is rotated
-        offsetX = heatmapRect.right > seriesViewRect.bottom ? heatmapRect.right - seriesViewRect.bottom : 0;
-    }
-    // Horizontal offsets == X offsets on texture, vertical offsets == Y offsets on texture
-    var horCellOffsets = calculateCellCoordinates(xCellSizes, heatmapRect.width, horStartInd, horCellCount, horInc, -offsetX);
-    var vertCellOffsets = calculateCellCoordinates(yCellSizes, heatmapRect.height, vertStartInd, vertCellCount, vertInc, -offsetY);
-    return { horCellOffsets: horCellOffsets, vertCellOffsets: vertCellOffsets };
-};
-/**
- * Calculates absolute coordinates of the heatmap cells
- * @param inputArr relative cell sizes
- * @param dimension texture size
- * @param startInd
- * @param count
- * @param inc
- * @param offset
- * @returns
- */
-var calculateCellCoordinates = function (inputArr, dimension, startInd, count, inc, offset) {
-    // Find a stretch coef
-    var sum = 0;
-    var ind = startInd;
-    for (var i = 0; i < count; i++, ind += inc) {
-        sum += inputArr[ind];
-    }
-    var coef = 1 / sum;
-    var offsets = new Array(count);
-    var length = offset;
-    for (var i = 0; i < count - 1; i++) {
-        var index = i * inc + startInd;
-        var cellSize = inputArr[index] * coef * dimension;
-        length = length + cellSize;
-        offsets[i] = length;
-    }
-    offsets[count - 1] = dimension + offset;
-    return offsets;
-};
-var calculateHeatmapTexture = function (colorDataParams, intVector, heatTextureCache) {
-    var textureWidth = colorDataParams.textureWidth, textureHeight = colorDataParams.textureHeight, webAssemblyContext = colorDataParams.webAssemblyContext, useInterpolation = colorDataParams.useInterpolation;
-    // calculate colors from zValues
-    // per pixel colors
-    var colorArray = getColorDataForTexture(colorDataParams, intVector);
-    // create and fill texture
-    var texture = heatTextureCache.create(textureWidth, textureHeight, webAssemblyContext.eTSRTextureFormat.TSR_TEXTUREFORMAT_A8B8G8R8);
-    webAssemblyContext.SCRTSetTextureLinearSamplerEnabled(texture, useInterpolation);
-    webAssemblyContext.SCRTFillTextureAbgr(texture, textureWidth, textureHeight, colorArray);
-    return texture;
-};

package/Charting/Visuals/RenderableSeries/DrawingProviders/OhlcSeriesDrawingProvider.d.ts

@@ -19,6 +19,7 @@ export declare class OhlcSeriesDrawingProvider extends BaseSeriesDrawingProvider
     private brushUpCache;
     private brushDownCache;
     private drawingMode;
+    private args;
     /**
      * Creates an instance of the {@link OhlcSeriesDrawingProvider}
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} containing native methods and

package/Charting/Visuals/RenderableSeries/DrawingProviders/OhlcSeriesDrawingProvider.js

@@ -43,6 +43,7 @@ var OhlcSeriesDrawingProvider = /** @class */ (function (_super) {
         var _this = _super.call(this, webAssemblyContext, parentSeries) || this;
         _this.drawingMode = drawingMode;
         _this.nativeDrawingProvider = new _this.webAssemblyContext.SCRTCandlestickSeriesDrawingProvider();
+        _this.args = new _this.webAssemblyContext.SCRTOhlcDrawingParams();
         var strokeThickness = parentSeries.strokeThickness, strokeUp = parentSeries.strokeUp, strokeDown = parentSeries.strokeDown, opacity = parentSeries.opacity;
         var candlestickSeries = parentSeries;
         _this.strokeUpPenCache = new Pen2DCache_1.Pen2DCache(webAssemblyContext);
@@ -95,47 +96,70 @@ var OhlcSeriesDrawingProvider = /** @class */ (function (_super) {
      * @inheritDoc
      */
     OhlcSeriesDrawingProvider.prototype.draw = function (renderContext, renderPassData) {
+        var _a;
         var pointSeries = renderPassData.pointSeries;
-        var args = new this.webAssemblyContext.SCRTOhlcDrawingParams();
-        try {
-            // Candles only requires brush up, down
-            if (this.drawingMode === EOhlcDrawingMode.Candles) {
-                var brushUp = (0, BrushCache_1.getScrtBrushFromCache)(this.brushUpCache);
-                var brushDown = (0, BrushCache_1.getScrtBrushFromCache)(this.brushDownCache);
-                if (!brushUp || !brushDown) {
-                    return;
-                }
-                args.SetBrushes(brushUp, brushDown);
-            }
-            var strokeUpPen = (0, Pen2DCache_1.getScrtPenFromCache)(this.strokeUpPenCache);
-            var strokeDownPen = (0, Pen2DCache_1.getScrtPenFromCache)(this.strokeDownPenCache);
-            // OHLC and Candle both require stroke up, down
-            if (!strokeUpPen || !strokeDownPen) {
+        this.args.Reset();
+        // Candles only requires brush up, down
+        if (this.drawingMode === EOhlcDrawingMode.Candles) {
+            var brushUp = (0, BrushCache_1.getScrtBrushFromCache)(this.brushUpCache);
+            var brushDown = (0, BrushCache_1.getScrtBrushFromCache)(this.brushDownCache);
+            if (!brushUp || !brushDown) {
                 return;
             }
-            args.SetPens(strokeUpPen, strokeDownPen);
-            // Paletting per point
-            var neutralColor = "#ffffffff";
-            _super.prototype.applyStrokeFillPaletting.call(this, neutralColor, undefined, neutralColor, undefined, this.parentSeries.opacity);
-            args.SetPalettedColors(this.palettingState.palettedColors);
-            args.forceShaderMethod = true;
-            args.verticalChart = renderPassData.isVerticalChart;
-            args.candleWidth = this.parentSeries.getDataPointWidth(renderPassData.xCoordinateCalculator, this.parentSeries.dataPointWidth);
-            args.drawAsOhlc = this.drawingMode === EOhlcDrawingMode.Ohlc;
-            var nativeContext = renderContext.getNativeContext();
-            var viewRect = this.parentSeries.parentSurface.seriesViewRect;
-            // const dataSeries = this.parentSeries.dataSeries as OhlcDataSeries;
-            var isCategoryAxis = renderPassData.xCoordinateCalculator.isCategoryCoordinateCalculator;
-            var xValues = pointSeries.xValues;
-            var openValues = pointSeries.openValues;
-            var highValues = pointSeries.highValues;
-            var lowValues = pointSeries.lowValues;
-            var closeValues = pointSeries.closeValues;
-            args.count = closeValues.size();
-            this.nativeDrawingProvider.DrawPointsVec(nativeContext, isCategoryAxis ? pointSeries.indexes : xValues, openValues, highValues, lowValues, closeValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, args);
+            this.args.SetBrushes(brushUp, brushDown);
+        }
+        var strokeUpPen = (0, Pen2DCache_1.getScrtPenFromCache)(this.strokeUpPenCache);
+        var strokeDownPen = (0, Pen2DCache_1.getScrtPenFromCache)(this.strokeDownPenCache);
+        // OHLC and Candle both require stroke up, down
+        if (!strokeUpPen || !strokeDownPen) {
+            return;
+        }
+        this.args.SetPens(strokeUpPen, strokeDownPen);
+        // Paletting per point
+        var neutralColor = "#ffffffff";
+        _super.prototype.applyStrokeFillPaletting.call(this, neutralColor, undefined, neutralColor, undefined, this.parentSeries.opacity);
+        this.args.SetPalettedColors(this.palettingState.palettedColors);
+        this.args.forceShaderMethod = true;
+        this.args.verticalChart = renderPassData.isVerticalChart;
+        this.args.candleWidth = this.parentSeries.getDataPointWidth(renderPassData.xCoordinateCalculator, this.parentSeries.dataPointWidth);
+        this.args.drawAsOhlc = this.drawingMode === EOhlcDrawingMode.Ohlc;
+        var nativeContext = renderContext.getNativeContext();
+        var viewRect = this.parentSeries.parentSurface.seriesViewRect;
+        var dataSeries = this.parentSeries.dataSeries;
+        var isCategoryAxis = renderPassData.xCoordinateCalculator.isCategoryCoordinateCalculator;
+        var xValues = pointSeries.xValues;
+        var openValues = pointSeries.openValues;
+        var highValues = pointSeries.highValues;
+        var lowValues = pointSeries.lowValues;
+        var closeValues = pointSeries.closeValues;
+        if (!pointSeries.resampled && ((_a = renderPassData.indexRange) === null || _a === void 0 ? void 0 : _a.diff) > 0) {
+            this.args.count = Math.min(renderPassData.indexRange.diff + 1, closeValues.size());
+            this.args.startIndex = renderPassData.indexRange.min;
         }
-        finally {
-            args.delete();
+        else {
+            this.args.count = closeValues.size();
+        }
+        var _b = this.parentSeries.dataSeries, fifoCapacity = _b.fifoCapacity, fifoSweeping = _b.fifoSweeping, fifoSweepingGap = _b.fifoSweepingGap;
+        var fifoStartIndex = pointSeries.fifoStartIndex;
+        if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count()) {
+            this.args.count = fifoStartIndex;
+        }
+        // let sx = "";
+        // let sy = "";
+        // for (let i = 0; i < closeValues.size(); i++) {
+        //     sx += pointSeries.indexes.get(i) + ",";
+        //     sy += closeValues.get(i).toFixed(2) + ",";
+        // }
+        // console.log(sx);
+        // console.log(sy);
+        var xDrawValues = isCategoryAxis ? pointSeries.indexes : xValues;
+        this.nativeDrawingProvider.DrawPointsVec(nativeContext, xDrawValues, openValues, highValues, lowValues, closeValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, this.args);
+        if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count()) {
+            this.args.startIndex = Math.min(closeValues.size(), fifoStartIndex + fifoSweepingGap);
+            this.args.count = Math.max(0, closeValues.size() - fifoStartIndex - fifoSweepingGap);
+            if (this.args.count > 0) {
+                this.nativeDrawingProvider.DrawPointsVec(nativeContext, xDrawValues, openValues, highValues, lowValues, closeValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, this.args);
+            }
         }
     };
     /**
@@ -147,6 +171,7 @@ var OhlcSeriesDrawingProvider = /** @class */ (function (_super) {
         this.brushUpCache = (0, Deleter_1.deleteSafe)(this.brushUpCache);
         this.brushDownCache = (0, Deleter_1.deleteSafe)(this.brushDownCache);
         this.nativeDrawingProvider = (0, Deleter_1.deleteSafe)(this.nativeDrawingProvider);
+        this.args = (0, Deleter_1.deleteSafe)(this.args);
         _super.prototype.delete.call(this);
     };
     return OhlcSeriesDrawingProvider;

package/Charting/Visuals/RenderableSeries/DrawingProviders/PointMarkerDrawingProvider.js

@@ -54,7 +54,7 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
      * @inheritDoc
      */
     PointMarkerDrawingProvider.prototype.draw = function (renderContext, renderPassData) {
-        var _a;
+        var _a, _b;
         var pointMarker = (_a = this.getProperties(this.parentSeries)) === null || _a === void 0 ? void 0 : _a.pointMarker;
         if (pointMarker === undefined) {
             return;
@@ -84,18 +84,45 @@ var PointMarkerDrawingProvider = /** @class */ (function (_super) {
             }
         }
         this.args.Reset();
-        this.args.count = yValues.size();
         this.args.verticalChart = renderPassData.isVerticalChart;
         this.args.forceShaderMethod = true;
         this.args.SetSpriteTexture(spriteTexture.getTexture());
         if (strokeMaskTexture) {
             this.args.SetStrokeMask(strokeMaskTexture.getTexture());
         }
+        var _c = this.parentSeries.dataSeries, fifoCapacity = _c.fifoCapacity, fifoSweeping = _c.fifoSweeping, fifoSweepingGap = _c.fifoSweepingGap;
+        var fifoStartIndex = pointSeries.fifoStartIndex;
+        if (pointMarker.lastPointOnly && yValues.size() > 0) {
+            this.args.count = 1;
+            this.args.startIndex =
+                fifoSweeping && this.parentSeries.dataSeries.count() === fifoCapacity
+                    ? fifoStartIndex - 1
+                    : yValues.size() - 1;
+        }
+        else {
+            if (!pointSeries.resampled && ((_b = renderPassData.indexRange) === null || _b === void 0 ? void 0 : _b.diff) > 0) {
+                this.args.count = Math.min(renderPassData.indexRange.diff + 1, yValues.size());
+                this.args.startIndex = renderPassData.indexRange.min;
+            }
+            else {
+                this.args.count = yValues.size();
+            }
+            if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count()) {
+                this.args.count = fifoStartIndex;
+            }
+        }
         // Paletting per point
-        _super.prototype.applyStrokeFillPaletting.call(this, pointMarker.stroke, undefined, pointMarker.fill, undefined, this.parentSeries.opacity);
+        this.applyStrokeFillPaletting(pointMarker.stroke, undefined, pointMarker.fill, undefined, this.parentSeries.opacity);
         this.args.SetPalettedColors(this.palettingState.palettedColors);
         var nativeContext = renderContext.getNativeContext();
         this.drawPoints(nativeContext, isCategoryAxis ? pointSeries.indexes : xValues, yValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, this.args, this.parentSeries.parentSurface.seriesViewRect);
+        if (fifoSweeping && fifoCapacity === this.parentSeries.dataSeries.count() && !pointMarker.lastPointOnly) {
+            this.args.startIndex = Math.min(yValues.size(), fifoStartIndex + fifoSweepingGap);
+            this.args.count = Math.max(0, yValues.size() - fifoStartIndex - fifoSweepingGap);
+            if (this.args.count > 0) {
+                this.drawPoints(nativeContext, isCategoryAxis ? pointSeries.indexes : xValues, yValues, renderPassData.xCoordinateCalculator.nativeCalculator, renderPassData.yCoordinateCalculator.nativeCalculator, this.args, this.parentSeries.parentSurface.seriesViewRect);
+            }
+        }
     };
     /**
      * @inheritDoc

package/Charting/Visuals/RenderableSeries/DrawingProviders/UniformHeatmapDrawingProvider.d.ts

@@ -29,6 +29,7 @@ export declare class UniformHeatmapDrawingProvider extends BaseSeriesDrawingProv
      * @inheritDoc
      */
     onSeriesPropertyChange(propertyName: string): void;
+    protected seriesHasDataChanges(): void;
     /**
      * @inheritDoc
      */

package/Charting/Visuals/RenderableSeries/DrawingProviders/UniformHeatmapDrawingProvider.js

@@ -59,7 +59,7 @@ var UniformHeatmapDrawingProvider = /** @class */ (function (_super) {
         var recreatePalette = propertyName === constants_1.PROPERTY.COLOR_MAP ||
             propertyName.includes(BaseHeatmapRenderableSeries_1.COLOR_MAP_PREFIX) ||
             propertyName === constants_1.PROPERTY.OPACITY;
-        var recreateHeat = propertyName === constants_1.PROPERTY.DATA_SERIES || constants_1.PROPERTY.USE_LINEAR_TEXTURE_FILTERING;
+        var recreateHeat = propertyName === constants_1.PROPERTY.DATA_SERIES || propertyName === constants_1.PROPERTY.USE_LINEAR_TEXTURE_FILTERING;
         if (recreatePalette) {
             this.recreatePalette();
         }
@@ -75,6 +75,9 @@ var UniformHeatmapDrawingProvider = /** @class */ (function (_super) {
             }
         }
     };
+    UniformHeatmapDrawingProvider.prototype.seriesHasDataChanges = function () {
+        this.onSeriesPropertyChange(constants_1.PROPERTY.DATA_SERIES);
+    };
     /**
      * @inheritDoc
      */

package/Charting/Visuals/RenderableSeries/FastBubbleRenderableSeries.d.ts

@@ -74,8 +74,6 @@ export declare class FastBubbleRenderableSeries extends BaseRenderableSeries {
      * @param pointIndex
      */
     getBubbleDiameter(pointIndex: number): number;
-    /** @inheritDoc */
-    delete(): void;
     /**
      * Returns the {@link XyyDataSeries.getNativeZValues} for the associated {@link dataSeries}
      */

package/Charting/Visuals/RenderableSeries/FastBubbleRenderableSeries.js

@@ -124,10 +124,6 @@ var FastBubbleRenderableSeries = /** @class */ (function (_super) {
     FastBubbleRenderableSeries.prototype.getBubbleDiameter = function (pointIndex) {
         return this.dataSeries.getNativeZValues().get(pointIndex);
     };
-    /** @inheritDoc */
-    FastBubbleRenderableSeries.prototype.delete = function () {
-        _super.prototype.delete.call(this);
-    };
     /**
      * Returns the {@link XyyDataSeries.getNativeZValues} for the associated {@link dataSeries}
      */

package/Charting/Visuals/RenderableSeries/FastTextRenderableSeries.d.ts

@@ -1,5 +1,6 @@
 import { ESeriesType } from "../../../types/SeriesType";
 import { TSciChart } from "../../../types/TSciChart";
+import { ResamplingParams } from "../../Numerics/Resamplers/ResamplingParams";
 import { BaseRenderableSeries } from "./BaseRenderableSeries";
 import { ITextDataLabelProviderOptions } from "./DataLabels/TextDataLabelProvider";
 import { IHitTestProvider } from "./HitTest/IHitTestProvider";
@@ -13,5 +14,7 @@ export interface ITextRenderableSeriesOptions extends IBaseRenderableSeriesOptio
 export declare class FastTextRenderableSeries extends BaseRenderableSeries {
     type: ESeriesType;
     constructor(webAssemblyContext: TSciChart, options?: ITextRenderableSeriesOptions);
+    /** @inheritDoc */
+    needsResampling(rp: ResamplingParams): boolean;
     protected newHitTestProvider(): IHitTestProvider;
 }

package/Charting/Visuals/RenderableSeries/FastTextRenderableSeries.js

@@ -17,6 +17,7 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastTextRenderableSeries = void 0;
 var SeriesType_1 = require("../../../types/SeriesType");
+var ResamplingMode_1 = require("../../Numerics/Resamplers/ResamplingMode");
 var BaseRenderableSeries_1 = require("./BaseRenderableSeries");
 var TextDataLabelProvider_1 = require("./DataLabels/TextDataLabelProvider");
 var PointMarkerDrawingProvider_1 = require("./DrawingProviders/PointMarkerDrawingProvider");
@@ -37,6 +38,15 @@ var FastTextRenderableSeries = /** @class */ (function (_super) {
         }
         return _this;
     }
+    /** @inheritDoc */
+    FastTextRenderableSeries.prototype.needsResampling = function (rp) {
+        if (this.dataSeries.fifoCapacity) {
+            rp.resamplingMode = ResamplingMode_1.EResamplingMode.None;
+            this.resamplerHelper.resetAndFillBasicNativeArgs(rp, this.getNativeXValues());
+            return true;
+        }
+        return false;
+    };
     FastTextRenderableSeries.prototype.newHitTestProvider = function () {
         return new TextSeriesHitTestProvider_1.TextSeriesHitTestProvider(this, this.webAssemblyContext);
     };

package/Charting/Visuals/RenderableSeries/HitTest/BubbleSeriesHitTestProvider.d.ts

@@ -9,6 +9,10 @@ export declare class BubbleSeriesHitTestProvider extends BaseHitTestProvider<Fas
      * @inheritDoc
      */
     hitTest(x: number, y: number, hitTestRadius?: number): HitTestInfo;
+    /**
+     * @inheritDoc
+     */
+    hitTestDataPoint(x: number, y: number, hitTestRadius?: number): HitTestInfo;
     /**
      * @inheritDoc
      */

package/Charting/Visuals/RenderableSeries/HitTest/BubbleSeriesHitTestProvider.js

@@ -77,6 +77,13 @@ var BubbleSeriesHitTestProvider = /** @class */ (function (_super) {
         }
         return hitTestInfo;
     };
+    /**
+     * @inheritDoc
+     */
+    BubbleSeriesHitTestProvider.prototype.hitTestDataPoint = function (x, y, hitTestRadius) {
+        if (hitTestRadius === void 0) { hitTestRadius = BaseHitTestProvider_1.BaseHitTestProvider.DEFAULT_HIT_TEST_RADIUS; }
+        return this.hitTest(x, y, hitTestRadius);
+    };
     /**
      * @inheritDoc
      */

package/Charting/Visuals/RenderableSeries/HitTest/HitTestInfo.d.ts

@@ -10,6 +10,10 @@ export declare class HitTestInfo {
      * The default empty {@link HitTestInfo} instance
      */
     static empty(): HitTestInfo;
+    /**
+     * Euclidean distance between the hitTestPoint and the nearest data-point
+     */
+    getEuclideanDistance(): number;
     /**
      * Gets the associated series that this {@link HitTestInfo} was generated by
      */

package/Charting/Visuals/RenderableSeries/HitTest/HitTestInfo.js

@@ -16,6 +16,15 @@ var HitTestInfo = /** @class */ (function () {
     HitTestInfo.empty = function () {
         return new HitTestInfo(undefined, true);
     };
+    /**
+     * Euclidean distance between the hitTestPoint and the nearest data-point
+     */
+    HitTestInfo.prototype.getEuclideanDistance = function () {
+        var _a, _b;
+        var dx = ((_a = this.hitTestPoint) === null || _a === void 0 ? void 0 : _a.x) - this.xCoord;
+        var dy = ((_b = this.hitTestPoint) === null || _b === void 0 ? void 0 : _b.y) - this.yCoord;
+        return Math.sqrt(dx * dx + dy * dy);
+    };
     return HitTestInfo;
 }());
 exports.HitTestInfo = HitTestInfo;

package/Charting/Visuals/RenderableSeries/ShaderEffect.d.ts

@@ -5,6 +5,7 @@ import { PropertyChangedEventArgs } from "../../../Core/PropertyChangedEventArgs
 import { EShaderEffectType } from "../../../types/ShaderEffectType";
 import { SCRTSeriesEffect, TSciChart } from "../../../types/TSciChart";
 import { IDeletable } from "../../../Core/IDeletable";
+import { DeletableEntity } from "../../../Core/DeletableEntity";
 export interface IShaderEffectOptions {
     intensity?: number;
     range?: number;
@@ -15,13 +16,13 @@ export interface IShaderEffectOptions {
  * A {@link ShaderEffect} can be applied to a {@link BaseRenderableSeries | RenderableSeries} via the
  * {@link BaseRenderableSeries.effect} property. The effect modifies the render output of the chart type.
  */
-export declare abstract class ShaderEffect implements IDeletable {
+export declare abstract class ShaderEffect extends DeletableEntity implements IDeletable {
     abstract readonly type: EShaderEffectType;
     /**
      * Event handler for when properties change, signalling that the parent {@link SciChartSurface} needs to redraw
      */
     propertyChanged: EventHandler<PropertyChangedEventArgs>;
-    private readonly webAssemblyContext;
+    private webAssemblyContext;
     private nativeEffect;
     private offsetProperty;
     private colorProperty;