Exemplo n.º 1
0
  /**
   * ******************************************************************************************
   * Draws the chart
   *
   * @param axisChart
   * @param iAxisChartDataSet
   * @throws PropertyException
   *     *******************************************************************************************
   */
  static void render(AxisChart axisChart, IAxisChartDataSet iAxisChartDataSet)
      throws PropertyException {
    Graphics2D g2d = axisChart.getGraphics2D();

    LineChartProperties lineChartProperties =
        (LineChartProperties) iAxisChartDataSet.getChartTypeProperties();
    lineChartProperties.validate(iAxisChartDataSet);

    // DataAxisProperties dataAxisProperties= (DataAxisProperties)
    // axisChart.getAxisProperties().getYAxisProperties();
    IDataSeries iDataSeries = (IDataSeries) axisChart.getIAxisDataSeries();

    // ---cache the computed values
    float[][] yAxisCoordinates =
        new float[iAxisChartDataSet.getNumberOfDataSets()]
            [iAxisChartDataSet.getNumberOfDataItems()];

    // ---need this for image map calculation
    float xMapCoordinate = axisChart.getXAxis().getTickStart();

    // LOOP
    for (int j = 0; j < iAxisChartDataSet.getNumberOfDataItems(); j++) {
      // LOOP
      for (int i = 0; i < yAxisCoordinates.length; i++) {
        if (iAxisChartDataSet.getValue(i, j) != Double.NaN) {
          yAxisCoordinates[i][j] =
              axisChart
                  .getYAxis()
                  .computeAxisCoordinate(
                      axisChart.getYAxis().getOrigin(),
                      iAxisChartDataSet.getValue(i, j),
                      axisChart.getYAxis().getScaleCalculator().getMinValue());

          // ---if we are generating an ImageMap, store the image coordinates
          if (axisChart.getGenerateImageMapFlag()) {
            String label;
            if (axisChart.getXAxis().getAxisLabelsGroup() != null) {
              label = axisChart.getXAxis().getAxisLabelsGroup().getTextTag(j).getText();
            } else {
              label = null;
            }

            axisChart
                .getImageMap()
                .addImageMapArea(
                    new CircleMapArea(
                        xMapCoordinate,
                        yAxisCoordinates[i][j],
                        iAxisChartDataSet.getValue(i, j),
                        label,
                        iAxisChartDataSet.getLegendLabel(i)));
          }
        } else {
          yAxisCoordinates[i][j] = Float.NaN;
        }
      }

      xMapCoordinate += axisChart.getXAxis().getScalePixelWidth();
    }

    AffineTransform originalTransform = null;
    double[] cornerXOffset = null;
    double[] cornerYOffset = null;

    // ---check if there are any points to display
    if (lineChartProperties.getShapes() != null) {
      // ---when centering the shapes on the points, need x and y offset to do this
      cornerXOffset = new double[iAxisChartDataSet.getNumberOfDataSets()];
      cornerYOffset = new double[iAxisChartDataSet.getNumberOfDataSets()];

      // ---get the original transform so can reset it.
      originalTransform = g2d.getTransform();

      Rectangle2D rectangle;

      // LOOP
      // ---pre-compute the dimensions of each Shape so do not do it in loop.
      for (int i = 0; i < iAxisChartDataSet.getNumberOfDataSets(); i++) {
        if (lineChartProperties.getShapes()[i] != null) {
          rectangle = lineChartProperties.getShapes()[i].getBounds2D();
          cornerXOffset[i] = rectangle.getWidth() / 2;
          cornerYOffset[i] = rectangle.getHeight() / 2;
        }
      }
    }

    // ---init for first segment
    Line2D.Float line =
        new Line2D.Float(
            axisChart.getXAxis().getTickStart(),
            yAxisCoordinates[0][0],
            axisChart.getXAxis().getTickStart(),
            yAxisCoordinates[0][0]);
    // ---make sure not plotting a chart with only one data point.
    if (yAxisCoordinates[0].length > 1) {
      line.y2 = yAxisCoordinates[0][1];
    }

    // LOOP
    // ---draw each line to the image
    for (int i = 0; i < yAxisCoordinates.length; i++) {
      line.x1 = axisChart.getXAxis().getTickStart();
      line.y1 = yAxisCoordinates[i][0];
      line.x2 = line.x1;

      // LOOP
      for (int j = 1; j < yAxisCoordinates[0].length; j++) {
        // ---if current point on line should be drawn
        if (!Float.isNaN(yAxisCoordinates[i][j])) {
          // ---if the previous point was not drawn, no line
          if (Float.isNaN(yAxisCoordinates[i][j - 1])) {
            line.x2 += axisChart.getXAxis().getScalePixelWidth();
            line.x1 = line.x2;
            line.y1 = yAxisCoordinates[i][j];
            line.y2 = yAxisCoordinates[i][j];

            continue;
          }

          line.x2 += axisChart.getXAxis().getScalePixelWidth();
          line.y2 = yAxisCoordinates[i][j];

          g2d.setPaint(iAxisChartDataSet.getPaint(i));
          g2d.setStroke(lineChartProperties.getLineStrokes()[i]);
          g2d.draw(line);

          // ---plot the Point
          if (lineChartProperties.getShapes()[i] != null) {
            // ---translate the Shape into position.
            g2d.translate(line.x1 - cornerXOffset[i], line.y1 - cornerYOffset[i]);

            g2d.setPaint(iAxisChartDataSet.getPaint(i));
            g2d.fill(lineChartProperties.getShapes()[i]);

            // ---translate back to the original position
            g2d.setTransform(originalTransform);
          }

          line.x1 = line.x2;
          line.y1 = line.y2;
        } else {
          if ((!Float.isNaN(yAxisCoordinates[i][j - 1]))
              && (lineChartProperties.getShapes()[i] != null)) {
            // ---translate the Shape into position.
            g2d.translate(line.x1 - cornerXOffset[i], line.y1 - cornerYOffset[i]);

            g2d.setPaint(iAxisChartDataSet.getPaint(i));
            g2d.fill(lineChartProperties.getShapes()[i]);

            // ---translate back to the original position
            g2d.setTransform(originalTransform);
          }

          line.x2 += axisChart.getXAxis().getScalePixelWidth();
          line.x1 = line.x2;
        }
      }

      // ---put the last shape on the line
      if ((!Float.isNaN(yAxisCoordinates[i][yAxisCoordinates[i].length - 1]))
          && (lineChartProperties.getShapes()[i] != null)) {
        // ---translate the Shape into position.
        g2d.translate(line.x2 - cornerXOffset[i], line.y2 - cornerYOffset[i]);

        g2d.setPaint(iAxisChartDataSet.getPaint(i));
        g2d.fill(lineChartProperties.getShapes()[i]);

        // ---translate back to the original position
        g2d.setTransform(originalTransform);
      }
    }
  }
Exemplo n.º 2
0
  /**
   * ******************************************************************************************
   * Draws the chart
   *
   * @param axisChart
   * @param iAxisChartDataSet
   *     *******************************************************************************************
   */
  static void render(AxisChart axisChart, IAxisChartDataSet iAxisChartDataSet) {
    // ---hopefully eliminate support requests asking about this...
    if (axisChart.getImageMap() != null) {
      // todo should we do a point image map?
      throw new ImageMapNotSupportedException(
          "HTML client-side image maps are not supported on Area Charts.");
    }

    // AreaChartProperties areaChartProperties=(AreaChartProperties)
    // iAxisChartDataSet.getChartTypeProperties();
    float xPosition = axisChart.getXAxis().getTickStart();

    GeneralPath generalPaths[] = new GeneralPath[iAxisChartDataSet.getNumberOfDataSets()];

    // ---AreaCharts can not be drawn on a horizontal axis so y-axis will always be the data axis
    DataAxisProperties dataAxisProperties =
        (DataAxisProperties) axisChart.getAxisProperties().getYAxisProperties();

    // LOOP
    // ---initial postion of each line must be set with call to moveTo()
    // ---Do this here so every point does not have to check....if( i == 0 )... in loop
    for (int i = 0; i < generalPaths.length; i++) {
      generalPaths[i] = new GeneralPath();
      generalPaths[i].moveTo(xPosition, axisChart.getYAxis().getZeroLineCoordinate());
      generalPaths[i].lineTo(
          xPosition,
          axisChart
              .getYAxis()
              .computeAxisCoordinate(
                  axisChart.getYAxis().getOrigin(),
                  iAxisChartDataSet.getValue(i, 0),
                  axisChart.getYAxis().getScaleCalculator().getMinValue()));
    }

    // LOOP
    for (int j = 1; j < iAxisChartDataSet.getNumberOfDataItems(); j++) {
      xPosition += axisChart.getXAxis().getScalePixelWidth();

      // LOOP
      for (int i = 0; i < generalPaths.length; i++) {
        generalPaths[i].lineTo(
            xPosition,
            axisChart
                .getYAxis()
                .computeAxisCoordinate(
                    axisChart.getYAxis().getOrigin(),
                    iAxisChartDataSet.getValue(i, j),
                    axisChart.getYAxis().getScaleCalculator().getMinValue()));
      }
    }

    Area[] areas = new Area[generalPaths.length];

    // LOOP
    // ---close the path. Do this here so do not have to check if last every pass through above
    // loop.
    for (int i = 0; i < generalPaths.length; i++) {
      generalPaths[i].lineTo(xPosition, axisChart.getYAxis().getZeroLineCoordinate());
      generalPaths[i].closePath();

      areas[i] = new Area(generalPaths[i]);
    }

    Graphics2D g2d = axisChart.getGraphics2D();

    // LOOP
    // ---draw each path to the image
    for (int i = 0; i < areas.length; i++) {
      g2d.setPaint(iAxisChartDataSet.getPaint(i));
      g2d.fill(areas[i]);
    }
  }