Examples with PointValue lecho.lib.hellocharts.model.PointValue used on opensource projects

Example 6 with PointValue

use of lecho.lib.hellocharts.model.PointValue in project dobby-android by InceptAi.

the class RtGraphViewHolder method setupLineChart.

private void setupLineChart() {
    List<Line> lineList = new ArrayList<>(1);
    List<Float> rawPoints = graphData.getData();
    List<PointValue> pointList = new ArrayList<>(rawPoints.size());
    for (int i = 0; i < rawPoints.size(); i++) {
        pointList.add(new PointValue(i, rawPoints.get(i)));
    }
    Line line = new Line(pointList);
    line.setColor(ChartUtils.COLOR_ORANGE);
    line.setHasPoints(false);
    lineList.add(line);
    lineChartData.setLines(lineList);
    Axis axisX = new Axis();
    axisX.setLineColor(ChartUtils.COLOR_GREEN);
    axisX.setName("Time");
    Axis axisY = new Axis();
    axisY.setLineColor(ChartUtils.COLOR_GREEN);
    axisY.setName("Bandwidth");
    lineChartData.setAxisYLeft(axisY);
    lineChartData.setAxisXBottom(axisX);
    lineChartView.setLineChartData(lineChartData);
    resetViewport();
}

Example 7 with PointValue

use of lecho.lib.hellocharts.model.PointValue in project hellocharts-android by lecho.

the class ComboLineColumnChartView method callTouchListener.

@Override
public void callTouchListener() {
    SelectedValue selectedValue = chartRenderer.getSelectedValue();
    if (selectedValue.isSet()) {
        if (SelectedValueType.COLUMN.equals(selectedValue.getType())) {
            SubcolumnValue value = data.getColumnChartData().getColumns().get(selectedValue.getFirstIndex()).getValues().get(selectedValue.getSecondIndex());
            onValueTouchListener.onColumnValueSelected(selectedValue.getFirstIndex(), selectedValue.getSecondIndex(), value);
        } else if (SelectedValueType.LINE.equals(selectedValue.getType())) {
            PointValue value = data.getLineChartData().getLines().get(selectedValue.getFirstIndex()).getValues().get(selectedValue.getSecondIndex());
            onValueTouchListener.onPointValueSelected(selectedValue.getFirstIndex(), selectedValue.getSecondIndex(), value);
        } else {
            throw new IllegalArgumentException("Invalid selected value type " + selectedValue.getType().name());
        }
    } else {
        onValueTouchListener.onValueDeselected();
    }
}

Example 8 with PointValue

use of lecho.lib.hellocharts.model.PointValue in project hellocharts-android by lecho.

the class LineChartRenderer method drawPoints.

// TODO Drawing points can be done in the same loop as drawing lines but it
// may cause problems in the future with
// implementing point styles.
private void drawPoints(Canvas canvas, Line line, int lineIndex, int mode) {
    pointPaint.setColor(line.getPointColor());
    int valueIndex = 0;
    for (PointValue pointValue : line.getValues()) {
        int pointRadius = ChartUtils.dp2px(density, line.getPointRadius());
        final float rawX = computator.computeRawX(pointValue.getX());
        final float rawY = computator.computeRawY(pointValue.getY());
        if (computator.isWithinContentRect(rawX, rawY, checkPrecision)) {
            // float rounding problems.
            if (MODE_DRAW == mode) {
                drawPoint(canvas, line, pointValue, rawX, rawY, pointRadius);
                if (line.hasLabels()) {
                    drawLabel(canvas, line, pointValue, rawX, rawY, pointRadius + labelOffset);
                }
            } else if (MODE_HIGHLIGHT == mode) {
                highlightPoint(canvas, line, pointValue, rawX, rawY, lineIndex, valueIndex);
            } else {
                throw new IllegalStateException("Cannot process points in mode: " + mode);
            }
        }
        ++valueIndex;
    }
}

Example 9 with PointValue

use of lecho.lib.hellocharts.model.PointValue in project hellocharts-android by lecho.

the class LineChartRenderer method calculateMaxViewport.

private void calculateMaxViewport() {
    tempMaximumViewport.set(Float.MAX_VALUE, Float.MIN_VALUE, Float.MIN_VALUE, Float.MAX_VALUE);
    LineChartData data = dataProvider.getLineChartData();
    for (Line line : data.getLines()) {
        // Calculate max and min for viewport.
        for (PointValue pointValue : line.getValues()) {
            if (pointValue.getX() < tempMaximumViewport.left) {
                tempMaximumViewport.left = pointValue.getX();
            }
            if (pointValue.getX() > tempMaximumViewport.right) {
                tempMaximumViewport.right = pointValue.getX();
            }
            if (pointValue.getY() < tempMaximumViewport.bottom) {
                tempMaximumViewport.bottom = pointValue.getY();
            }
            if (pointValue.getY() > tempMaximumViewport.top) {
                tempMaximumViewport.top = pointValue.getY();
            }
        }
    }
}

Example 10 with PointValue

use of lecho.lib.hellocharts.model.PointValue in project hellocharts-android by lecho.

the class LineChartRenderer method drawSmoothPath.

private void drawSmoothPath(Canvas canvas, final Line line) {
    prepareLinePaint(line);
    final int lineSize = line.getValues().size();
    float prePreviousPointX = Float.NaN;
    float prePreviousPointY = Float.NaN;
    float previousPointX = Float.NaN;
    float previousPointY = Float.NaN;
    float currentPointX = Float.NaN;
    float currentPointY = Float.NaN;
    float nextPointX = Float.NaN;
    float nextPointY = Float.NaN;
    for (int valueIndex = 0; valueIndex < lineSize; ++valueIndex) {
        if (Float.isNaN(currentPointX)) {
            PointValue linePoint = line.getValues().get(valueIndex);
            currentPointX = computator.computeRawX(linePoint.getX());
            currentPointY = computator.computeRawY(linePoint.getY());
        }
        if (Float.isNaN(previousPointX)) {
            if (valueIndex > 0) {
                PointValue linePoint = line.getValues().get(valueIndex - 1);
                previousPointX = computator.computeRawX(linePoint.getX());
                previousPointY = computator.computeRawY(linePoint.getY());
            } else {
                previousPointX = currentPointX;
                previousPointY = currentPointY;
            }
        }
        if (Float.isNaN(prePreviousPointX)) {
            if (valueIndex > 1) {
                PointValue linePoint = line.getValues().get(valueIndex - 2);
                prePreviousPointX = computator.computeRawX(linePoint.getX());
                prePreviousPointY = computator.computeRawY(linePoint.getY());
            } else {
                prePreviousPointX = previousPointX;
                prePreviousPointY = previousPointY;
            }
        }
        // nextPoint is always new one or it is equal currentPoint.
        if (valueIndex < lineSize - 1) {
            PointValue linePoint = line.getValues().get(valueIndex + 1);
            nextPointX = computator.computeRawX(linePoint.getX());
            nextPointY = computator.computeRawY(linePoint.getY());
        } else {
            nextPointX = currentPointX;
            nextPointY = currentPointY;
        }
        if (valueIndex == 0) {
            // Move to start point.
            path.moveTo(currentPointX, currentPointY);
        } else {
            // Calculate control points.
            final float firstDiffX = (currentPointX - prePreviousPointX);
            final float firstDiffY = (currentPointY - prePreviousPointY);
            final float secondDiffX = (nextPointX - previousPointX);
            final float secondDiffY = (nextPointY - previousPointY);
            final float firstControlPointX = previousPointX + (LINE_SMOOTHNESS * firstDiffX);
            final float firstControlPointY = previousPointY + (LINE_SMOOTHNESS * firstDiffY);
            final float secondControlPointX = currentPointX - (LINE_SMOOTHNESS * secondDiffX);
            final float secondControlPointY = currentPointY - (LINE_SMOOTHNESS * secondDiffY);
            path.cubicTo(firstControlPointX, firstControlPointY, secondControlPointX, secondControlPointY, currentPointX, currentPointY);
        }
        // Shift values by one back to prevent recalculation of values that have
        // been already calculated.
        prePreviousPointX = previousPointX;
        prePreviousPointY = previousPointY;
        previousPointX = currentPointX;
        previousPointY = currentPointY;
        currentPointX = nextPointX;
        currentPointY = nextPointY;
    }
    canvas.drawPath(path, linePaint);
    if (line.isFilled()) {
        drawArea(canvas, line);
    }
    path.reset();
}