scichart 2.1.2301 → 2.2.2389

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

@@ -0,0 +1,252 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorSeriesDrawingProvider = void 0;
+var Deleter_1 = require("../../../../Core/Deleter");
+var AxisType_1 = require("../../../../types/AxisType");
+var DataPointWidthMode_1 = require("../../../../types/DataPointWidthMode");
+var ErrorDirection_1 = require("../../../../types/ErrorDirection");
+var ErrorMode_1 = require("../../../../types/ErrorMode");
+var Pen2DCache_1 = require("../../../Drawing/Pen2DCache");
+var WebGlRenderContext2D_1 = require("../../../Drawing/WebGlRenderContext2D");
+var LogarithmicAxis_1 = require("../../Axis/LogarithmicAxis");
+var constants_1 = require("../constants");
+var BaseSeriesDrawingProvider_1 = require("./BaseSeriesDrawingProvider");
+/**
+ * Used internally - a drawing provider performs drawing for a {@link BaseBandRenderableSeries} using
+ * our WebAssembly WebGL rendering engine
+ */
+var ErrorSeriesDrawingProvider = /** @class */ (function (_super) {
+    __extends(ErrorSeriesDrawingProvider, _super);
+    // private args: SCRTLineDrawingParams;
+    // private xLineCoordinates: SCRTDoubleVector;
+    // private yLineCoordinates: SCRTDoubleVector;
+    /**
+     * Creates an instance of the {@link BandSeriesDrawingProvider}
+     * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} containing native methods and
+     * access to our WebGL2 Engine and WebAssembly numerical methods
+     * @param parentSeries the parent {@link BaseBandRenderableSeries} which this drawing provider is attached to
+     */
+    function ErrorSeriesDrawingProvider(webAssemblyContext, parentSeries) {
+        var _this = _super.call(this, webAssemblyContext, parentSeries) || this;
+        _this.linesPenCache = new Pen2DCache_1.Pen2DCache(webAssemblyContext);
+        _this.vertices = new _this.webAssemblyContext.VectorColorVertex();
+        return _this;
+        // this.args = new webAssemblyContext.SCRTLineDrawingParams();
+        // this.xLineCoordinates = new this.webAssemblyContext.SCRTDoubleVector();
+        // this.yLineCoordinates = new this.webAssemblyContext.SCRTDoubleVector();
+    }
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesDrawingProvider.prototype.onAttachSeries = function () {
+        _super.prototype.onAttachSeries.call(this);
+        // this.nativeDrawingProvider = new this.webAssemblyContext.SCRTLineSeriesDrawingProvider();
+        var _a = this.parentSeries, stroke = _a.stroke, strokeThickness = _a.strokeThickness, opacity = _a.opacity, strokeDashArray = _a.strokeDashArray;
+        (0, Pen2DCache_1.createPenInCache)(this.linesPenCache, stroke, strokeThickness, opacity, strokeDashArray);
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesDrawingProvider.prototype.onDetachSeries = function () {
+        _super.prototype.onDetachSeries.call(this);
+        this.delete();
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesDrawingProvider.prototype.delete = function () {
+        // this.nativeDrawingProvider = deleteSafe(this.nativeDrawingProvider);
+        this.linesPenCache = (0, Deleter_1.deleteSafe)(this.linesPenCache);
+        this.vertices = (0, Deleter_1.deleteSafe)(this.vertices);
+        // this.args = deleteSafe(this.args);
+        _super.prototype.delete.call(this);
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesDrawingProvider.prototype.draw = function (renderContext, renderPassData) {
+        var linesPen = (0, Pen2DCache_1.getScrtPenFromCache)(this.linesPenCache);
+        if (!linesPen) {
+            return;
+        }
+        var pointSeries = renderPassData.pointSeries;
+        this.vertices.clear();
+        // this.xLineCoordinates.clear();
+        // this.yLineCoordinates.clear();
+        // this.args.Reset();
+        // this.args.SetLinesPen(linesPen);
+        // this.args.isDigitalLine = this.parentSeries.isDigitalLine;
+        // this.args.forceShaderMethod = true;
+        // this.args.containsNaN = true;
+        // this.args.lineGaps = this.webAssemblyContext.SCRTLineGapMode.DrawGaps;
+        // this.args.verticalChart = renderPassData.isVerticalChart;
+        // // Stroke paletting per point
+        // this.applyStrokePaletting(linesPen);
+        // if (this.palettingState.palettedColors) {
+        //     this.args.SetPalettedColors(this.palettingState.palettedColors);
+        // }
+        // const nativeContext = renderContext.getNativeContext();
+        var isCategoryAxis = renderPassData.xCoordinateCalculator.isCategoryCoordinateCalculator;
+        var xValues = pointSeries.xValues;
+        var xDrawValues = isCategoryAxis ? pointSeries.indexes : xValues;
+        var yDrawValues = pointSeries.yValues;
+        var hDrawValues = pointSeries.highValues;
+        var lDrawValues = pointSeries.lowValues;
+        var isVerticalDirection = this.parentSeries.errorDirection === ErrorDirection_1.EErrorDirection.Vertical;
+        var dataPointWidthCalc = isVerticalDirection
+            ? renderPassData.xCoordinateCalculator
+            : renderPassData.yCoordinateCalculator;
+        var dataPointWidthPx = this.parentSeries.dataPointWidthMode === DataPointWidthMode_1.EDataPointWidthMode.Absolute
+            ? this.parentSeries.dataPointWidth
+            : this.parentSeries.getDataPointWidth(dataPointWidthCalc, this.parentSeries.dataPointWidth);
+        // const halfRange = Math.abs(
+        //     dataPointWidthCalc.getDataValue(dataPointWidthPx * 0.5) - dataPointWidthCalc.getDataValue(0)
+        // );
+        var halfRange = dataPointWidthPx * 0.5;
+        var hasLogarithmicXAxis = this.parentSeries.xAxis.type === AxisType_1.EAxisType.LogarithmicAxis;
+        var hasLogarithmicYAxis = this.parentSeries.yAxis.type === AxisType_1.EAxisType.LogarithmicAxis;
+        var hasNegativeLogXAxis = this.parentSeries.xAxis.isNegative;
+        var hasNegativeLogYAxis = this.parentSeries.yAxis.isNegative;
+        var hasHighCap = this.parentSeries.errorMode !== ErrorMode_1.EErrorMode.Low;
+        var hasLowCap = this.parentSeries.errorMode !== ErrorMode_1.EErrorMode.High;
+        var dataPointsCount = xDrawValues.size();
+        if (isVerticalDirection) {
+            for (var i = 0; i < dataPointsCount; ++i) {
+                var xValue = xDrawValues.get(i);
+                var yValue = yDrawValues.get(i);
+                var highValue = hasHighCap ? hDrawValues.get(i) : yValue;
+                var lowValue = hasLowCap ? lDrawValues.get(i) : yValue;
+                var shouldDrawLowErrorToLimit = hasLogarithmicYAxis && !hasNegativeLogYAxis && lowValue <= 0;
+                if (shouldDrawLowErrorToLimit) {
+                    lowValue = this.parentSeries.yAxis.visibleRange.min;
+                }
+                var shouldDrawHighErrorToLimit = hasLogarithmicYAxis && hasNegativeLogYAxis && highValue >= 0;
+                if (shouldDrawHighErrorToLimit) {
+                    highValue = this.parentSeries.yAxis.visibleRange.max;
+                }
+                // const xCoord = xValue;
+                // const yCoord = yValue;
+                // const highCoord = highValue;
+                // const lowCoord = lowValue;
+                var xCoord = renderPassData.xCoordinateCalculator.getCoordinate(xValue);
+                var yCoord = renderPassData.yCoordinateCalculator.getCoordinate(yValue);
+                var highCoord = renderPassData.yCoordinateCalculator.getCoordinate(highValue);
+                var lowCoord = renderPassData.yCoordinateCalculator.getCoordinate(lowValue);
+                var capStart = xCoord - halfRange;
+                var capEnd = xCoord + halfRange;
+                // main line
+                if (this.parentSeries.drawConnector) {
+                    this.addLineVertices(xCoord, isNaN(highValue) ? yCoord : highCoord, xCoord, isNaN(lowValue) ? yCoord : lowCoord);
+                }
+                if (hasHighCap && !shouldDrawHighErrorToLimit && this.parentSeries.drawWhiskers) {
+                    // top whiskers
+                    this.addLineVertices(capStart, highCoord, capEnd, highCoord);
+                }
+                if (hasLowCap && !shouldDrawLowErrorToLimit && this.parentSeries.drawWhiskers) {
+                    // bottom whiskers
+                    this.addLineVertices(capStart, lowCoord, capEnd, lowCoord);
+                }
+            }
+        }
+        else {
+            for (var i = 0; i < dataPointsCount; ++i) {
+                var xValue = xDrawValues.get(i);
+                var yValue = yDrawValues.get(i);
+                var lowValue = hasLowCap ? lDrawValues.get(i) : xValue;
+                var highValue = hasHighCap ? hDrawValues.get(i) : xValue;
+                var shouldDrawLowErrorToLimit = hasLogarithmicXAxis && !hasNegativeLogXAxis && lowValue <= 0;
+                if (shouldDrawLowErrorToLimit) {
+                    lowValue = LogarithmicAxis_1.MIN_LOG_AXIS_VALUE;
+                }
+                var shouldDrawHighErrorToLimit = hasLogarithmicXAxis && hasNegativeLogXAxis && highValue >= 0;
+                if (shouldDrawHighErrorToLimit) {
+                    highValue = -LogarithmicAxis_1.MIN_LOG_AXIS_VALUE;
+                }
+                // const xCoord = xValue;
+                // const yCoord = yValue;
+                // const highCoord = highValue;
+                // const lowCoord = lowValue;
+                var xCoord = renderPassData.xCoordinateCalculator.getCoordinate(xValue);
+                var yCoord = renderPassData.yCoordinateCalculator.getCoordinate(yValue);
+                var highCoord = renderPassData.xCoordinateCalculator.getCoordinate(highValue);
+                var lowCoord = renderPassData.xCoordinateCalculator.getCoordinate(lowValue);
+                var capStart = yCoord - halfRange;
+                var capEnd = yCoord + halfRange;
+                // main line
+                if (this.parentSeries.drawConnector) {
+                    this.addLineVertices(isNaN(lowValue) ? xCoord : lowCoord, yCoord, isNaN(highValue) ? xCoord : highCoord, yCoord);
+                }
+                if (hasHighCap && !shouldDrawHighErrorToLimit && this.parentSeries.drawWhiskers) {
+                    // top whiskers
+                    this.addLineVertices(highCoord, capStart, highCoord, capEnd);
+                }
+                if (hasLowCap && !shouldDrawLowErrorToLimit && this.parentSeries.drawWhiskers) {
+                    // bottom whiskers
+                    this.addLineVertices(lowCoord, capStart, lowCoord, capEnd);
+                }
+            }
+        }
+        // this.nativeDrawingProvider.DrawLinesVec(nativeContext, xValues, yValues, xCoordCalc, yCoordCalc, args);
+        renderContext.drawLinesNative(this.vertices, linesPen, WebGlRenderContext2D_1.ELineDrawMode.DiscontinuousLine);
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesDrawingProvider.prototype.onDpiChanged = function (args) {
+        _super.prototype.onDpiChanged.call(this, args);
+        this.onSeriesPropertyChange(constants_1.PROPERTY.STROKE);
+    };
+    /**
+     * @inheritDoc
+     */
+    ErrorSeriesDrawingProvider.prototype.onSeriesPropertyChange = function (propertyName) {
+        _super.prototype.onSeriesPropertyChange.call(this, propertyName);
+        var _a = this.parentSeries, stroke = _a.stroke, strokeThickness = _a.strokeThickness, opacity = _a.opacity, strokeDashArray = _a.strokeDashArray;
+        if (propertyName === constants_1.PROPERTY.STROKE ||
+            propertyName === constants_1.PROPERTY.STROKE_THICKNESS ||
+            propertyName === constants_1.PROPERTY.OPACITY ||
+            propertyName === constants_1.PROPERTY.STROKE_DASH_ARRAY) {
+            (0, Pen2DCache_1.createPenInCache)(this.linesPenCache, stroke, strokeThickness, opacity, strokeDashArray);
+        }
+    };
+    ErrorSeriesDrawingProvider.prototype.addLineVertices = function (x1, y1, x2, y2) {
+        var isVerticalChart = this.parentSeries.xAxis.isVerticalChart;
+        var vertex1;
+        var vertex2;
+        if (isVerticalChart) {
+            vertex1 = new this.webAssemblyContext.SCRTColorVertex(y1, x1);
+            vertex2 = new this.webAssemblyContext.SCRTColorVertex(y2, x2);
+        }
+        else {
+            vertex1 = new this.webAssemblyContext.SCRTColorVertex(x1, y1);
+            vertex2 = new this.webAssemblyContext.SCRTColorVertex(x2, y2);
+        }
+        this.vertices.push_back(vertex1);
+        this.vertices.push_back(vertex2);
+        vertex1.delete();
+        vertex2.delete();
+        // this.xLineCoordinates.push_back(x1);
+        // this.yLineCoordinates.push_back(x2);
+        // this.xLineCoordinates.push_back(y1);
+        // this.yLineCoordinates.push_back(y2);
+        // this.xLineCoordinates.push_back(NaN);
+        // this.yLineCoordinates.push_back(NaN);
+    };
+    return ErrorSeriesDrawingProvider;
+}(BaseSeriesDrawingProvider_1.BaseSeriesDrawingProvider));
+exports.ErrorSeriesDrawingProvider = ErrorSeriesDrawingProvider;

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

@@ -0,0 +1,188 @@
+import { NumberRange } from "../../../Core/NumberRange";
+import { EDataPointWidthMode } from "../../../types/DataPointWidthMode";
+import { EErrorDirection } from "../../../types/ErrorDirection";
+import { EErrorMode } from "../../../types/ErrorMode";
+import { ESeriesType } from "../../../types/SeriesType";
+import { TSciChart } from "../../../types/TSciChart";
+import { IPaletteProvider } from "../../Model/IPaletteProvider";
+import { IHlcPointSeries } from "../../Model/PointSeries/IPointSeries";
+import { CoordinateCalculatorBase } from "../../Numerics/CoordinateCalculators/CoordinateCalculatorBase";
+import { ResamplingParams } from "../../Numerics/Resamplers/ResamplingParams";
+import { IThemeProvider } from "../../Themes/IThemeProvider";
+import { BaseRenderableSeries } from "./BaseRenderableSeries";
+import { IHitTestProvider } from "./HitTest/IHitTestProvider";
+import { IBaseRenderableSeriesOptions } from "./IBaseRenderableSeriesOptions";
+/**
+ * Options to pass to the {@link FastErrorBarsRenderableSeries} constructor
+ */
+export interface IFastErrorBarsRenderableSeriesOptions extends IBaseRenderableSeriesOptions {
+    /**
+     * The StrokeDashArray defines the stroke or dash pattern for the line.
+     * Accepts an array of values, e.g. [2,2] will have a line of length 2 and a gap of length 2.
+     */
+    strokeDashArray?: number[];
+    /**
+     * The width of error bar caps.
+     * By default the value is treated as relative, valid values range from 0.0 - 1.0.
+     * To specify if the value should be treated as relative or absolute use {@link dataPointWidthMode}
+     */
+    dataPointWidth?: number;
+    /**
+     * The value mode for data point width. Available values are {@link EDataPointWidthMode}
+     */
+    dataPointWidthMode?: EDataPointWidthMode;
+    /**
+     * Gets or sets the errorMode of Error Bars. Available values are {@link EErrorMode}
+     */
+    errorMode?: EErrorMode;
+    /**
+     * The errorDirection of Error Bars. Available values are {@link EErrorDirection}
+     */
+    errorDirection?: EErrorDirection;
+    /**
+     * The flag defining whether Error Bars should be drawn with whiskers
+     * @remarks enabled by default
+     */
+    drawWhiskers?: boolean;
+    /**
+     * TThe flag defining whether Error Bars should be drawn with a connector
+     * @remarks enabled by default
+     */
+    drawConnector?: boolean;
+}
+/**
+ * Defines an Error Bars Series or Error Bars chart type in the SciChart's High Performance Real-time
+ * {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
+ * @remarks
+ * To add a line series to a {@link SciChartSurface} you need to declare both the {@link FastErrorBarsRenderableSeries | RenderableSeries}
+ * and a {@link HlcDataSeries | DataSeries}. Simplified code sample below:
+ *
+ * ```ts
+ * const sciChartSurface: SciChartSurface;
+ * const wasmContext: TSciChart;
+ * // Create and fill the dataseries
+ * const dataSeries = new HlcDataSeries(wasmContext);
+ * dataSeries.append(1, 2, 0,4, 0.5);
+ * dataSeries.append(2, 3, 0,2, 0.3);
+ * // Create the renderableSeries
+ * const errorSeries = new FastErrorBarsRenderableSeries(wasmContext);
+ * errorSeries.dataSeries = dataSeries;
+ * // append to the SciChartSurface
+ * sciChartSurface.renderableSeries.add(errorSeries);
+ * ```
+ */
+export declare class FastErrorBarsRenderableSeries extends BaseRenderableSeries {
+    readonly type = ESeriesType.ErrorBarsSeries;
+    private dataPointWidthProperty;
+    private dataPointWidthModeProperty;
+    private errorModeProperty;
+    private errorDirectionProperty;
+    private strokeDashArrayProperty;
+    private drawWhiskersProperty;
+    private drawConnectorProperty;
+    /**
+     * Creates an instance of the {@link FastErrorBarsRenderableSeries}
+     * @param webAssemblyContext The {@link TSciChart | SciChart WebAssembly Context} containing
+     * native methods and access to our WebGL2 WebAssembly Drawing Engine
+     * @param options optional parameters of type {@link IFastErrorBarsRenderableSeriesOptions} applied when constructing the series type
+     */
+    constructor(webAssemblyContext: TSciChart, options?: IFastErrorBarsRenderableSeriesOptions);
+    /** @inheritDoc */
+    applyTheme(themeProvider: IThemeProvider): void;
+    /**
+     * The StrokeDashArray defines the stroke or dash pattern for the line.
+     * Accepts an array of values, e.g. [2,2] will have a line of length 2 and a gap of length 2.
+     */
+    get strokeDashArray(): number[];
+    /**
+     * The StrokeDashArray defines the stroke or dash pattern for the line.
+     * Accepts an array of values, e.g. [2,2] will have a line of length 2 and a gap of length 2.
+     */
+    set strokeDashArray(strokeDashArray: number[]);
+    /**
+     * Gets or sets whether Error Bars should be drawn with whiskers
+     * @remarks enabled by default
+     */
+    get drawWhiskers(): boolean;
+    /**
+     * Gets or sets whether Error Bars should be drawn with whiskers
+     * @remarks enabled by default
+     */
+    set drawWhiskers(value: boolean);
+    /**
+     * Gets or sets whether Error Bars should be drawn with a connector
+     * @remarks enabled by default
+     */
+    get drawConnector(): boolean;
+    /**
+     * Gets or sets whether Error Bars should be drawn with a connector
+     * @remarks enabled by default
+     */
+    set drawConnector(value: boolean);
+    /**
+     * Gets or sets the paletteProvider of Renderable Series
+     * @remarks paletteProvider is not supported by {@link FastErrorBarsRenderableSeries}
+     */
+    get paletteProvider(): IPaletteProvider;
+    set paletteProvider(paletteProvider: IPaletteProvider);
+    /**
+     * Gets or sets the width of error bar caps.
+     * By default the value is treated as relative, valid values range from 0.0 - 1.0.
+     * @remarks
+     * To specify if the value should be treated as relative or absolute use {@link errorType}
+     */
+    get dataPointWidth(): number;
+    /**
+     * Gets or sets the width of error bar caps.
+     * By default the value is treated as relative, valid values range from 0.0 - 1.0.
+     * @remarks
+     * To specify if the value should be treated as relative or absolute use {@link dataPointWidthMode}
+     */
+    set dataPointWidth(value: number);
+    /**
+     * Gets or sets the errorMode of Error Bars. Available values are {@link EErrorMode}
+     */
+    get errorMode(): EErrorMode;
+    /**
+     * Gets or sets the errorMode of Error Bars. Available values are {@link EErrorMode}
+     */
+    set errorMode(value: EErrorMode);
+    /**
+     * Gets or sets the errorDirection of Error Bars. Available values are {@link EErrorDirection}
+     */
+    get errorDirection(): EErrorDirection;
+    /**
+     * Gets or sets the errorDirection of Error Bars. Available values are {@link EErrorDirection}
+     */
+    set errorDirection(value: EErrorDirection);
+    /**
+     * Gets or sets the value mode for data point width. Available values are {@link EDataPointWidthMode}
+     */
+    get dataPointWidthMode(): EDataPointWidthMode;
+    /**
+     * Gets or sets the value mode for data point width. Available values are {@link EDataPointWidthMode}
+     */
+    set dataPointWidthMode(value: EDataPointWidthMode);
+    delete(): void;
+    /**
+     *  @inheritDoc
+     */
+    getDataPointWidth(coordCalc: CoordinateCalculatorBase, widthFraction: number): number;
+    /**
+     * @inheritDoc
+     */
+    getXRange(): NumberRange;
+    /** @inheritDoc */
+    getYRange(xVisibleRange: NumberRange, isXCategoryAxis?: boolean): NumberRange;
+    /** @inheritDoc */
+    toJSON(excludeData?: boolean): import("../../../Builder/buildSeries").TSeriesDefinition;
+    /** @inheritDoc */
+    toPointSeries(rp?: ResamplingParams): IHlcPointSeries;
+    /**
+     * @inheritDoc
+     */
+    protected newHitTestProvider(): IHitTestProvider;
+    protected adjustRangeByDataPointWidth(range: NumberRange): NumberRange;
+}
+/** @ignore */
+export declare const adjustRangeByStrokeThickness: (range: NumberRange, strokeThickness: number, areaSize?: number) => NumberRange;