transformValues method

@override void transformValues()

Transforms the x and y values to screen coordinates.

Implementation

@override
void transformValues() {
  if (_xValues.isEmpty || _yValues.isEmpty || _errorBarValues.isEmpty) {
    return;
  }

  _verticalPath.reset();
  _verticalCapPath.reset();
  _horizontalPath.reset();
  _horizontalCapPath.reset();

  final PointToPixelCallback transformX = series.pointToPixelX;
  final PointToPixelCallback transformY = series.pointToPixelY;

  for (int i = 0; i < series.dataCount; i++) {
    double? verticalPositiveX;
    double? verticalPositiveY;
    double? verticalNegativeX;
    double? verticalNegativeY;
    double? horizontalPositiveX;
    double? horizontalPositiveY;
    double? horizontalNegativeX;
    double? horizontalNegativeY;

    final num xValue = _xValues[i];
    final num yValue = _yValues[i];
    final ErrorBarValues errorBarValues = _errorBarValues[i];

    if (animationFactor != 0) {
      final bool isTransposedChart = series.isTransposed;
      _errorBarMidPointX = transformX(xValue, yValue);
      _errorBarMidPointY = transformY(xValue, yValue);
      points.add(Offset(_errorBarMidPointX, _errorBarMidPointY));

      if (errorBarValues.verticalPositiveErrorValue != null) {
        verticalPositiveX =
            transformX(xValue, errorBarValues.verticalPositiveErrorValue!);
        verticalPositiveY =
            transformY(xValue, errorBarValues.verticalPositiveErrorValue!);
        points.add(Offset(verticalPositiveX, verticalPositiveY));
      }

      if (errorBarValues.verticalNegativeErrorValue != null) {
        verticalNegativeX =
            transformX(xValue, errorBarValues.verticalNegativeErrorValue!);
        verticalNegativeY =
            transformY(xValue, errorBarValues.verticalNegativeErrorValue!);
        points.add(Offset(verticalNegativeX, verticalNegativeY));
      }

      if (errorBarValues.horizontalPositiveErrorValue != null) {
        horizontalPositiveX =
            transformX(errorBarValues.horizontalPositiveErrorValue!, yValue);
        horizontalPositiveY =
            transformY(errorBarValues.horizontalPositiveErrorValue!, yValue);
        points.add(Offset(horizontalPositiveX, horizontalPositiveY));
      }

      if (errorBarValues.horizontalNegativeErrorValue != null) {
        horizontalNegativeX =
            transformX(errorBarValues.horizontalNegativeErrorValue!, yValue);
        horizontalNegativeY =
            transformY(errorBarValues.horizontalNegativeErrorValue!, yValue);
        points.add(Offset(horizontalNegativeX, horizontalNegativeY));
      }

      double animatingPoint;
      if (verticalPositiveX != null && verticalPositiveY != null) {
        animatingPoint = isTransposedChart
            ? _errorBarMidPointX +
                ((verticalPositiveX - _errorBarMidPointX) *
                    _effectiveAnimationFactor)
            : _errorBarMidPointY -
                ((_errorBarMidPointY - verticalPositiveY) *
                    _effectiveAnimationFactor);

        _capPointValue = animatingPoint -
            ((animatingPoint -
                    (isTransposedChart
                        ? verticalPositiveX
                        : verticalPositiveY)) *
                animationFactor);

        _calculateVerticalPath(_capPointValue, animationFactor,
            series.capLength!, isTransposedChart);
      }
      if (verticalNegativeX != null && verticalNegativeY != null) {
        animatingPoint = isTransposedChart
            ? _errorBarMidPointX +
                ((verticalNegativeX - _errorBarMidPointX) *
                    _effectiveAnimationFactor)
            : _errorBarMidPointY +
                ((verticalNegativeY - _errorBarMidPointY) *
                    _effectiveAnimationFactor);

        _capPointValue = animatingPoint +
            (((isTransposedChart ? verticalNegativeX : verticalNegativeY) -
                    animatingPoint) *
                animationFactor);

        _calculateVerticalPath(_capPointValue, animationFactor,
            series.capLength!, isTransposedChart);
      }
      if (horizontalPositiveX != null && horizontalPositiveY != null) {
        animatingPoint = isTransposedChart
            ? _errorBarMidPointY -
                ((_errorBarMidPointY - horizontalPositiveY) *
                    _effectiveAnimationFactor)
            : _errorBarMidPointX +
                ((horizontalPositiveX - _errorBarMidPointX) *
                    _effectiveAnimationFactor);

        _capPointValue = animatingPoint +
            (((isTransposedChart
                        ? horizontalPositiveY
                        : horizontalPositiveX) -
                    animatingPoint) *
                animationFactor);

        _calculateHorizontalPath(_capPointValue, animationFactor,
            series.capLength!, isTransposedChart);
      }
      if (horizontalNegativeX != null && horizontalNegativeY != null) {
        animatingPoint = isTransposedChart
            ? _errorBarMidPointY +
                ((horizontalNegativeY - _errorBarMidPointY) *
                    _effectiveAnimationFactor)
            : _errorBarMidPointX -
                ((_errorBarMidPointX - horizontalNegativeX) *
                    _effectiveAnimationFactor);

        _capPointValue = animatingPoint -
            ((animatingPoint -
                    (isTransposedChart
                        ? horizontalNegativeY
                        : horizontalNegativeX)) *
                animationFactor);

        _calculateHorizontalPath(_capPointValue, animationFactor,
            series.capLength!, isTransposedChart);
      }

      if (points.length > _oldPoints.length) {
        _oldPoints.addAll(points.sublist(_oldPoints.length));
      }
    }
  }
}