Examples with Point eu.hansolo.tilesfx.tools.Point used on opensource projects

Example 6 with Point

use of eu.hansolo.tilesfx.tools.Point in project tilesfx by HanSolo.

the class SmoothedChart method smooth.

private void smooth(ObservableList<PathElement> strokeElements, ObservableList<PathElement> fillElements, final double HEIGHT) {
    if (fillElements.isEmpty())
        return;
    // as we do not have direct access to the data, first recreate the list of all the data points we have
    final Point[] dataPoints = new Point[strokeElements.size()];
    for (int i = 0; i < strokeElements.size(); i++) {
        final PathElement element = strokeElements.get(i);
        if (element instanceof MoveTo) {
            final MoveTo move = (MoveTo) element;
            dataPoints[i] = new Point(move.getX(), move.getY());
        } else if (element instanceof LineTo) {
            final LineTo line = (LineTo) element;
            final double x = line.getX(), y = line.getY();
            dataPoints[i] = new Point(x, y);
        }
    }
    double firstX = dataPoints[0].getX();
    double lastX = dataPoints[dataPoints.length - 1].getX();
    Point[] points = Helper.subdividePoints(dataPoints, getSubDivisions());
    fillElements.clear();
    fillElements.add(new MoveTo(firstX, HEIGHT));
    strokeElements.clear();
    strokeElements.add(new MoveTo(points[0].getX(), points[0].getY()));
    for (Point p : points) {
        if (Double.compare(p.getX(), firstX) >= 0) {
            fillElements.add(new LineTo(p.getX(), p.getY()));
            strokeElements.add(new LineTo(p.getX(), p.getY()));
        }
    }
    fillElements.add(new LineTo(lastX, HEIGHT));
    fillElements.add(new LineTo(0, HEIGHT));
    fillElements.add(new ClosePath());
}

Example 7 with Point

use of eu.hansolo.tilesfx.tools.Point in project tilesfx by HanSolo.

the class RadarChart method drawChart.

private void drawChart() {
    final double CENTER_X = 0.5 * size;
    final double CENTER_Y = CENTER_X;
    final double CIRCLE_SIZE = 0.9 * size;
    final double DATA_RANGE = getRange();
    final double RANGE = 0.35714 * CIRCLE_SIZE;
    final double OFFSET = 0.14286 * CIRCLE_SIZE;
    final int NO_OF_SECTORS = getNoOfSectors();
    final double MIN_VALUE = getMinValue();
    final double MAX_VALUE = getMaxValue();
    // clear the chartCanvas
    chartCtx.clearRect(0, 0, size, size);
    // draw the chart data
    chartCtx.save();
    if (gradientStops.isEmpty()) {
        chartCtx.setFill(getChartFill());
    } else {
        chartCtx.setFill(new RadialGradient(0, 0, CENTER_X, CENTER_Y, CIRCLE_SIZE * 0.5, false, CycleMethod.NO_CYCLE, stops));
    }
    double radiusFactor;
    switch(getMode()) {
        case POLYGON:
            if (isSmoothing()) {
                double radAngle = Math.toRadians(180);
                double radAngleStep = Math.toRadians(angleStep);
                List<Point> points = new ArrayList<>();
                double x = CENTER_X + (-Math.sin(radAngle) * (CENTER_Y - (0.36239 * size)));
                double y = CENTER_Y + (+Math.cos(radAngle) * (CENTER_Y - (0.36239 * size)));
                points.add(new Point(x, y));
                for (int i = 0; i < NO_OF_SECTORS; i++) {
                    double r1 = (CENTER_Y - (CENTER_Y - OFFSET - ((data.get(i).getValue() - MIN_VALUE) / DATA_RANGE) * RANGE));
                    x = CENTER_X + (-Math.sin(radAngle) * r1);
                    y = CENTER_Y + (+Math.cos(radAngle) * r1);
                    points.add(new Point(x, y));
                    radAngle += radAngleStep;
                }
                double r3 = (CENTER_Y - (CENTER_Y - OFFSET - ((data.get(NO_OF_SECTORS - 1).getValue() - MIN_VALUE) / DATA_RANGE) * RANGE));
                x = CENTER_X + (-Math.sin(radAngle) * r3);
                y = CENTER_Y + (+Math.cos(radAngle) * r3);
                points.add(new Point(x, y));
                Point[] interpolatedPoints = Helper.subdividePoints(points.toArray(new Point[0]), 8);
                chartCtx.beginPath();
                chartCtx.moveTo(interpolatedPoints[0].getX(), interpolatedPoints[0].getY());
                for (int i = 0; i < interpolatedPoints.length - 1; i++) {
                    Point point = interpolatedPoints[i];
                    chartCtx.lineTo(point.getX(), point.getY());
                }
                chartCtx.lineTo(interpolatedPoints[interpolatedPoints.length - 1].getX(), interpolatedPoints[interpolatedPoints.length - 1].getY());
                chartCtx.closePath();
                chartCtx.fill();
            } else {
                chartCtx.beginPath();
                chartCtx.moveTo(CENTER_X, 0.36239 * size);
                for (int i = 0; i < NO_OF_SECTORS; i++) {
                    radiusFactor = (clamp(MIN_VALUE, MAX_VALUE, (data.get(i).getValue()) - MIN_VALUE) / DATA_RANGE);
                    // chartCtx.lineTo(CENTER_X, CENTER_Y - OFFSET - radiusFactor * RANGE);
                    chartCtx.lineTo(CENTER_X, CENTER_Y - OFFSET - radiusFactor * RANGE);
                    chartCtx.translate(CENTER_X, CENTER_Y);
                    chartCtx.rotate(angleStep);
                    chartCtx.translate(-CENTER_X, -CENTER_Y);
                }
                radiusFactor = ((clamp(MIN_VALUE, MAX_VALUE, data.get(NO_OF_SECTORS - 1).getValue()) - MIN_VALUE) / DATA_RANGE);
                chartCtx.lineTo(CENTER_X, CENTER_Y - OFFSET - radiusFactor * RANGE);
                chartCtx.closePath();
                chartCtx.fill();
            }
            break;
        case SECTOR:
            chartCtx.translate(CENTER_X, CENTER_Y);
            chartCtx.rotate(-90);
            chartCtx.translate(-CENTER_X, -CENTER_Y);
            // sector mode
            for (int i = 0; i < NO_OF_SECTORS; i++) {
                radiusFactor = (clamp(MIN_VALUE, MAX_VALUE, (data.get(i).getValue() - MIN_VALUE)) / DATA_RANGE);
                chartCtx.beginPath();
                chartCtx.moveTo(CENTER_X, CENTER_Y);
                chartCtx.arc(CENTER_X, CENTER_Y, radiusFactor * RANGE + OFFSET, radiusFactor * RANGE + OFFSET, 0, -angleStep);
                chartCtx.closePath();
                chartCtx.fill();
                chartCtx.translate(CENTER_X, CENTER_Y);
                chartCtx.rotate(angleStep);
                chartCtx.translate(-CENTER_X, -CENTER_Y);
            }
            break;
    }
    chartCtx.restore();
}

Example 8 with Point

use of eu.hansolo.tilesfx.tools.Point in project tilesfx by HanSolo.

the class RadarChart method drawOverlay.

private void drawOverlay() {
    final Paint CHART_BKG = getChartBackgroundColor();
    final double CENTER_X = 0.5 * size;
    final double CENTER_Y = CENTER_X;
    final double CIRCLE_SIZE = 0.90 * size;
    final double DATA_RANGE = getRange();
    final double RANGE = 0.35714 * CIRCLE_SIZE;
    final double OFFSET = 0.14286 * CIRCLE_SIZE;
    final int NO_OF_SECTORS = getNoOfSectors();
    final double MIN_VALUE = getMinValue();
    double radius;
    // clear the chartCanvas
    overlayCtx.clearRect(0, 0, size, size);
    // draw center point
    overlayCtx.save();
    overlayCtx.setFill(CHART_BKG);
    overlayCtx.translate(CENTER_X - OFFSET, CENTER_Y - OFFSET);
    overlayCtx.fillOval(0, 0, 2 * OFFSET, 2 * OFFSET);
    overlayCtx.restore();
    // draw concentric rings
    overlayCtx.setLineWidth(1);
    overlayCtx.setStroke(getGridColor());
    double ringStepSize = (CIRCLE_SIZE - CIRCLE_SIZE * 0.28571) / 20.0;
    double pos = 0.5 * (size - CIRCLE_SIZE);
    double ringSize = CIRCLE_SIZE;
    for (int i = 0; i < 11; i++) {
        overlayCtx.strokeOval(pos, pos, ringSize, ringSize);
        pos += ringStepSize;
        ringSize -= 2 * ringStepSize;
    }
    // draw star lines
    overlayCtx.save();
    for (int i = 0; i < NO_OF_SECTORS; i++) {
        overlayCtx.strokeLine(CENTER_X, 0.37 * size, CENTER_X, 0.5 * (size - CIRCLE_SIZE));
        overlayCtx.translate(CENTER_X, CENTER_Y);
        overlayCtx.rotate(angleStep);
        overlayCtx.translate(-CENTER_X, -CENTER_Y);
    }
    overlayCtx.restore();
    // draw threshold line
    if (isThresholdVisible()) {
        radius = ((getThreshold() - MIN_VALUE) / DATA_RANGE);
        overlayCtx.setLineWidth(clamp(1d, 3d, size * 0.005));
        overlayCtx.setStroke(getThresholdColor());
        overlayCtx.strokeOval(0.5 * size - OFFSET - radius * RANGE, 0.5 * size - OFFSET - radius * RANGE, 2 * (radius * RANGE + OFFSET), 2 * (radius * RANGE + OFFSET));
    }
    // prerotate if sectormode
    overlayCtx.save();
    if (Mode.SECTOR == getMode()) {
        overlayCtx.translate(CENTER_X, CENTER_Y);
        overlayCtx.rotate(angleStep * 0.5);
        overlayCtx.translate(-CENTER_X, -CENTER_Y);
    }
    // draw text
    overlayCtx.save();
    overlayCtx.setFont(Fonts.latoRegular(0.04 * size));
    overlayCtx.setTextAlign(TextAlignment.CENTER);
    overlayCtx.setTextBaseline(VPos.CENTER);
    overlayCtx.setFill(getChartForegroundColor());
    for (int i = 0; i < NO_OF_SECTORS; i++) {
        overlayCtx.fillText(data.get(i).getName(), CENTER_X, size * 0.02);
        overlayCtx.translate(CENTER_X, CENTER_Y);
        overlayCtx.rotate(angleStep);
        overlayCtx.translate(-CENTER_X, -CENTER_Y);
    }
    overlayCtx.restore();
    overlayCtx.restore();
}