Examples with PieDataset org.jfree.data.pie.PieDataset used on opensource projects

Example 1 with PieDataset

use of org.jfree.data.pie.PieDataset in project graphcode2vec by graphcode2vec.

the class DatasetReader method readPieDatasetFromXML.

/**
 * Reads a {@link PieDataset} from a stream.
 *
 * @param in  the input stream.
 *
 * @return A dataset.
 *
 * @throws IOException if there is an I/O error.
 */
public static PieDataset readPieDatasetFromXML(InputStream in) throws IOException {
    PieDataset result = null;
    SAXParserFactory factory = SAXParserFactory.newInstance();
    try {
        SAXParser parser = factory.newSAXParser();
        PieDatasetHandler handler = new PieDatasetHandler();
        parser.parse(in, handler);
        result = handler.getDataset();
    } catch (SAXException e) {
        System.out.println(e.getMessage());
    } catch (ParserConfigurationException e2) {
        System.out.println(e2.getMessage());
    }
    return result;
}

Example 2 with PieDataset

use of org.jfree.data.pie.PieDataset in project graphcode2vec by graphcode2vec.

the class RingPlot method drawItem.

/**
 * Draws a single data item.
 *
 * @param g2  the graphics device (<code>null</code> not permitted).
 * @param section  the section index.
 * @param dataArea  the data plot area.
 * @param state  state information for one chart.
 * @param currentPass  the current pass index.
 */
protected void drawItem(Graphics2D g2, int section, Rectangle2D dataArea, PiePlotState state, int currentPass) {
    PieDataset dataset = getDataset();
    Number n = dataset.getValue(section);
    if (n == null) {
        return;
    }
    double value = n.doubleValue();
    double angle1 = 0.0;
    double angle2 = 0.0;
    Rotation direction = getDirection();
    if (direction == Rotation.CLOCKWISE) {
        angle1 = state.getLatestAngle();
        angle2 = angle1 - value / state.getTotal() * 360.0;
    } else if (direction == Rotation.ANTICLOCKWISE) {
        angle1 = state.getLatestAngle();
        angle2 = angle1 + value / state.getTotal() * 360.0;
    } else {
        throw new IllegalStateException("Rotation type not recognised.");
    }
    double angle = (angle2 - angle1);
    if (Math.abs(angle) > getMinimumArcAngleToDraw()) {
        Comparable key = getSectionKey(section);
        double ep = 0.0;
        double mep = getMaximumExplodePercent();
        if (mep > 0.0) {
            ep = getExplodePercent(key) / mep;
        }
        Rectangle2D arcBounds = getArcBounds(state.getPieArea(), state.getExplodedPieArea(), angle1, angle, ep);
        Arc2D.Double arc = new Arc2D.Double(arcBounds, angle1, angle, Arc2D.OPEN);
        // create the bounds for the inner arc
        double depth = this.sectionDepth / 2.0;
        RectangleInsets s = new RectangleInsets(UnitType.RELATIVE, depth, depth, depth, depth);
        Rectangle2D innerArcBounds = new Rectangle2D.Double();
        innerArcBounds.setRect(arcBounds);
        s.trim(innerArcBounds);
        // calculate inner arc in reverse direction, for later
        // GeneralPath construction
        Arc2D.Double arc2 = new Arc2D.Double(innerArcBounds, angle1 + angle, -angle, Arc2D.OPEN);
        GeneralPath path = new GeneralPath();
        path.moveTo((float) arc.getStartPoint().getX(), (float) arc.getStartPoint().getY());
        path.append(arc.getPathIterator(null), false);
        path.append(arc2.getPathIterator(null), true);
        path.closePath();
        Line2D separator = new Line2D.Double(arc2.getEndPoint(), arc.getStartPoint());
        if (currentPass == 0) {
            Paint shadowPaint = getShadowPaint();
            double shadowXOffset = getShadowXOffset();
            double shadowYOffset = getShadowYOffset();
            if (shadowPaint != null) {
                Shape shadowArc = ShapeUtilities.createTranslatedShape(path, (float) shadowXOffset, (float) shadowYOffset);
                g2.setPaint(shadowPaint);
                g2.fill(shadowArc);
            }
        } else if (currentPass == 1) {
            Paint paint = lookupSectionPaint(key, false);
            g2.setPaint(paint);
            g2.fill(path);
            Paint outlinePaint = lookupSectionOutlinePaint(key, false);
            Stroke outlineStroke = lookupSectionOutlineStroke(key, false);
            if (outlinePaint != null && outlineStroke != null) {
                g2.setPaint(outlinePaint);
                g2.setStroke(outlineStroke);
                g2.draw(path);
            }
            // add an entity for the pie section
            if (state.getInfo() != null) {
                EntityCollection entities = state.getEntityCollection();
                if (entities != null) {
                    String tip = null;
                    PieToolTipGenerator toolTipGenerator = getToolTipGenerator();
                    if (toolTipGenerator != null) {
                        tip = toolTipGenerator.generateToolTip(dataset, key);
                    }
                    String url = null;
                    PieURLGenerator urlGenerator = getURLGenerator();
                    if (urlGenerator != null) {
                        url = urlGenerator.generateURL(dataset, key, getPieIndex());
                    }
                    PieSectionEntity entity = new PieSectionEntity(path, dataset, getPieIndex(), section, key, tip, url);
                    entities.add(entity);
                }
            }
        } else if (currentPass == 2) {
            if (this.separatorsVisible) {
                Line2D extendedSeparator = extendLine(separator, this.innerSeparatorExtension, this.outerSeparatorExtension);
                g2.setStroke(this.separatorStroke);
                g2.setPaint(this.separatorPaint);
                g2.draw(extendedSeparator);
            }
        }
    }
    state.setLatestAngle(angle2);
}

Example 3 with PieDataset

use of org.jfree.data.pie.PieDataset in project graphcode2vec by graphcode2vec.

the class MultiplePiePlot method draw.

/**
 * Draws the plot on a Java 2D graphics device (such as the screen or a
 * printer).
 *
 * @param g2  the graphics device.
 * @param area  the area within which the plot should be drawn.
 * @param anchor  the anchor point (<code>null</code> permitted).
 * @param parentState  the state from the parent plot, if there is one.
 * @param info  collects info about the drawing.
 */
public void draw(Graphics2D g2, Rectangle2D area, Point2D anchor, PlotState parentState, PlotRenderingInfo info) {
    // adjust the drawing area for the plot insets (if any)...
    RectangleInsets insets = getInsets();
    insets.trim(area);
    drawBackground(g2, area);
    drawOutline(g2, area);
    // check that there is some data to display...
    if (DatasetUtilities.isEmptyOrNull(this.dataset)) {
        drawNoDataMessage(g2, area);
        return;
    }
    int pieCount = 0;
    if (this.dataExtractOrder == TableOrder.BY_ROW) {
        pieCount = this.dataset.getRowCount();
    } else {
        pieCount = this.dataset.getColumnCount();
    }
    // the columns variable is always >= rows
    int displayCols = (int) Math.ceil(Math.sqrt(pieCount));
    int displayRows = (int) Math.ceil((double) pieCount / (double) displayCols);
    // swap rows and columns to match plotArea shape
    if (displayCols > displayRows && area.getWidth() < area.getHeight()) {
        int temp = displayCols;
        displayCols = displayRows;
        displayRows = temp;
    }
    prefetchSectionPaints();
    int x = (int) area.getX();
    int y = (int) area.getY();
    int width = ((int) area.getWidth()) / displayCols;
    int height = ((int) area.getHeight()) / displayRows;
    int row = 0;
    int column = 0;
    int diff = (displayRows * displayCols) - pieCount;
    int xoffset = 0;
    Rectangle rect = new Rectangle();
    for (int pieIndex = 0; pieIndex < pieCount; pieIndex++) {
        rect.setBounds(x + xoffset + (width * column), y + (height * row), width, height);
        String title = null;
        if (this.dataExtractOrder == TableOrder.BY_ROW) {
            title = this.dataset.getRowKey(pieIndex).toString();
        } else {
            title = this.dataset.getColumnKey(pieIndex).toString();
        }
        this.pieChart.setTitle(title);
        PieDataset piedataset = null;
        PieDataset dd = new CategoryToPieDataset(this.dataset, this.dataExtractOrder, pieIndex);
        if (this.limit > 0.0) {
            piedataset = DatasetUtilities.createConsolidatedPieDataset(dd, this.aggregatedItemsKey, this.limit);
        } else {
            piedataset = dd;
        }
        PiePlot piePlot = (PiePlot) this.pieChart.getPlot();
        piePlot.setDataset(piedataset);
        piePlot.setPieIndex(pieIndex);
        // update the section colors to match the global colors...
        for (int i = 0; i < piedataset.getItemCount(); i++) {
            Comparable key = piedataset.getKey(i);
            Paint p;
            if (key.equals(this.aggregatedItemsKey)) {
                p = this.aggregatedItemsPaint;
            } else {
                p = (Paint) this.sectionPaints.get(key);
            }
            piePlot.setSectionPaint(key, p);
        }
        ChartRenderingInfo subinfo = null;
        if (info != null) {
            subinfo = new ChartRenderingInfo();
        }
        this.pieChart.draw(g2, rect, subinfo);
        if (info != null) {
            info.getOwner().getEntityCollection().addAll(subinfo.getEntityCollection());
            info.addSubplotInfo(subinfo.getPlotInfo());
        }
        ++column;
        if (column == displayCols) {
            column = 0;
            ++row;
            if (row == displayRows - 1 && diff != 0) {
                xoffset = (diff * width) / 2;
            }
        }
    }
}

Example 4 with PieDataset

use of org.jfree.data.pie.PieDataset in project graphcode2vec by graphcode2vec.

the class PiePlot method setDataset.

/**
 * Sets the dataset and sends a {@link DatasetChangeEvent} to 'this'.
 *
 * @param dataset  the dataset (<code>null</code> permitted).
 *
 * @see #getDataset()
 */
public void setDataset(PieDataset dataset) {
    // if there is an existing dataset, remove the plot from the list of
    // change listeners...
    PieDataset existing = this.dataset;
    if (existing != null) {
        existing.removeChangeListener(this);
    }
    // set the new dataset, and register the chart as a change listener...
    this.dataset = dataset;
    if (dataset != null) {
        setDatasetGroup(dataset.getGroup());
        dataset.addChangeListener(this);
    }
    // send a dataset change event to self...
    DatasetChangeEvent event = new DatasetChangeEvent(this, dataset, new PieDatasetChangeInfo(PieDatasetChangeType.UPDATE, -1, -1));
    datasetChanged(event);
}

Example 5 with PieDataset

use of org.jfree.data.pie.PieDataset in project graphcode2vec by graphcode2vec.

the class PiePlot3D method draw.

/**
 * Draws the plot on a Java 2D graphics device (such as the screen or a
 * printer).  This method is called by the
 * {@link org.jfree.chart.JFreeChart} class, you don't normally need
 * to call it yourself.
 *
 * @param g2  the graphics device.
 * @param plotArea  the area within which the plot should be drawn.
 * @param anchor  the anchor point.
 * @param parentState  the state from the parent plot, if there is one.
 * @param info  collects info about the drawing
 *              (<code>null</code> permitted).
 */
public void draw(Graphics2D g2, Rectangle2D plotArea, Point2D anchor, PlotState parentState, PlotRenderingInfo info) {
    // adjust for insets...
    RectangleInsets insets = getInsets();
    insets.trim(plotArea);
    Rectangle2D originalPlotArea = (Rectangle2D) plotArea.clone();
    if (info != null) {
        info.setPlotArea(plotArea);
        info.setDataArea(plotArea);
    }
    drawBackground(g2, plotArea);
    Shape savedClip = g2.getClip();
    g2.clip(plotArea);
    // adjust the plot area by the interior spacing value
    double gapPercent = getInteriorGap();
    double labelPercent = 0.0;
    if (getLabelGenerator() != null) {
        labelPercent = getLabelGap() + getMaximumLabelWidth();
    }
    double gapHorizontal = plotArea.getWidth() * (gapPercent + labelPercent) * 2.0;
    double gapVertical = plotArea.getHeight() * gapPercent * 2.0;
    if (DEBUG_DRAW_INTERIOR) {
        double hGap = plotArea.getWidth() * getInteriorGap();
        double vGap = plotArea.getHeight() * getInteriorGap();
        double igx1 = plotArea.getX() + hGap;
        double igx2 = plotArea.getMaxX() - hGap;
        double igy1 = plotArea.getY() + vGap;
        double igy2 = plotArea.getMaxY() - vGap;
        g2.setPaint(Color.lightGray);
        g2.draw(new Rectangle2D.Double(igx1, igy1, igx2 - igx1, igy2 - igy1));
    }
    double linkX = plotArea.getX() + gapHorizontal / 2;
    double linkY = plotArea.getY() + gapVertical / 2;
    double linkW = plotArea.getWidth() - gapHorizontal;
    double linkH = plotArea.getHeight() - gapVertical;
    // make the link area a square if the pie chart is to be circular...
    if (isCircular()) {
        // is circular?
        double min = Math.min(linkW, linkH) / 2;
        linkX = (linkX + linkX + linkW) / 2 - min;
        linkY = (linkY + linkY + linkH) / 2 - min;
        linkW = 2 * min;
        linkH = 2 * min;
    }
    PiePlotState state = initialise(g2, plotArea, this, null, info);
    // the link area defines the dog leg points for the linking lines to
    // the labels
    Rectangle2D linkAreaXX = new Rectangle2D.Double(linkX, linkY, linkW, linkH * (1 - this.depthFactor));
    state.setLinkArea(linkAreaXX);
    if (DEBUG_DRAW_LINK_AREA) {
        g2.setPaint(Color.blue);
        g2.draw(linkAreaXX);
        g2.setPaint(Color.yellow);
        g2.draw(new Ellipse2D.Double(linkAreaXX.getX(), linkAreaXX.getY(), linkAreaXX.getWidth(), linkAreaXX.getHeight()));
    }
    // the explode area defines the max circle/ellipse for the exploded pie
    // sections.
    // it is defined by shrinking the linkArea by the linkMargin factor.
    double hh = linkW * getLabelLinkMargin();
    double vv = linkH * getLabelLinkMargin();
    Rectangle2D explodeArea = new Rectangle2D.Double(linkX + hh / 2.0, linkY + vv / 2.0, linkW - hh, linkH - vv);
    state.setExplodedPieArea(explodeArea);
    // the pie area defines the circle/ellipse for regular pie sections.
    // it is defined by shrinking the explodeArea by the explodeMargin
    // factor.
    double maximumExplodePercent = getMaximumExplodePercent();
    double percent = maximumExplodePercent / (1.0 + maximumExplodePercent);
    double h1 = explodeArea.getWidth() * percent;
    double v1 = explodeArea.getHeight() * percent;
    Rectangle2D pieArea = new Rectangle2D.Double(explodeArea.getX() + h1 / 2.0, explodeArea.getY() + v1 / 2.0, explodeArea.getWidth() - h1, explodeArea.getHeight() - v1);
    // the link area defines the dog-leg point for the linking lines to
    // the labels
    int depth = (int) (pieArea.getHeight() * this.depthFactor);
    Rectangle2D linkArea = new Rectangle2D.Double(linkX, linkY, linkW, linkH - depth);
    state.setLinkArea(linkArea);
    state.setPieArea(pieArea);
    state.setPieCenterX(pieArea.getCenterX());
    state.setPieCenterY(pieArea.getCenterY() - depth / 2.0);
    state.setPieWRadius(pieArea.getWidth() / 2.0);
    state.setPieHRadius((pieArea.getHeight() - depth) / 2.0);
    // get the data source - return if null;
    PieDataset dataset = getDataset();
    if (DatasetUtilities.isEmptyOrNull(getDataset())) {
        drawNoDataMessage(g2, plotArea);
        g2.setClip(savedClip);
        drawOutline(g2, plotArea);
        return;
    }
    // if too any elements
    if (dataset.getKeys().size() > plotArea.getWidth()) {
        String text = "Too many elements";
        Font sfont = new Font("Tahoma", Font.BOLD, 10);
        g2.setFont(sfont);
        FontMetrics fm = g2.getFontMetrics(sfont);
        int stringWidth = fm.stringWidth(text);
        g2.drawString(text, (int) (plotArea.getX() + (plotArea.getWidth() - stringWidth) / 2), (int) (plotArea.getY() + (plotArea.getHeight() / 2)));
        return;
    }
    // effect.
    if (isCircular()) {
        double min = Math.min(plotArea.getWidth(), plotArea.getHeight()) / 2;
        plotArea = new Rectangle2D.Double(plotArea.getCenterX() - min, plotArea.getCenterY() - min, 2 * min, 2 * min);
    }
    // get a list of keys...
    List sectionKeys = dataset.getKeys();
    if (sectionKeys.size() == 0) {
        return;
    }
    // establish the coordinates of the top left corner of the drawing area
    double arcX = pieArea.getX();
    double arcY = pieArea.getY();
    // g2.clip(clipArea);
    Composite originalComposite = g2.getComposite();
    g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, getForegroundAlpha()));
    double totalValue = DatasetUtilities.calculatePieDatasetTotal(dataset);
    double runningTotal = 0;
    if (depth < 0) {
        // if depth is negative don't draw anything
        return;
    }
    ArrayList arcList = new ArrayList();
    Arc2D.Double arc;
    Paint paint;
    Paint outlinePaint;
    Stroke outlineStroke;
    Iterator iterator = sectionKeys.iterator();
    while (iterator.hasNext()) {
        Comparable currentKey = (Comparable) iterator.next();
        Number dataValue = dataset.getValue(currentKey);
        if (dataValue == null) {
            arcList.add(null);
            continue;
        }
        double value = dataValue.doubleValue();
        if (value <= 0) {
            arcList.add(null);
            continue;
        }
        double startAngle = getStartAngle();
        double direction = getDirection().getFactor();
        double angle1 = startAngle + (direction * (runningTotal * 360)) / totalValue;
        double angle2 = startAngle + (direction * (runningTotal + value) * 360) / totalValue;
        if (Math.abs(angle2 - angle1) > getMinimumArcAngleToDraw()) {
            arcList.add(new Arc2D.Double(arcX, arcY + depth, pieArea.getWidth(), pieArea.getHeight() - depth, angle1, angle2 - angle1, Arc2D.PIE));
        } else {
            arcList.add(null);
        }
        runningTotal += value;
    }
    Shape oldClip = g2.getClip();
    Ellipse2D top = new Ellipse2D.Double(pieArea.getX(), pieArea.getY(), pieArea.getWidth(), pieArea.getHeight() - depth);
    Ellipse2D bottom = new Ellipse2D.Double(pieArea.getX(), pieArea.getY() + depth, pieArea.getWidth(), pieArea.getHeight() - depth);
    Rectangle2D lower = new Rectangle2D.Double(top.getX(), top.getCenterY(), pieArea.getWidth(), bottom.getMaxY() - top.getCenterY());
    Rectangle2D upper = new Rectangle2D.Double(pieArea.getX(), top.getY(), pieArea.getWidth(), bottom.getCenterY() - top.getY());
    Area a = new Area(top);
    a.add(new Area(lower));
    Area b = new Area(bottom);
    b.add(new Area(upper));
    Area pie = new Area(a);
    pie.intersect(b);
    Area front = new Area(pie);
    front.subtract(new Area(top));
    Area back = new Area(pie);
    back.subtract(new Area(bottom));
    // draw the bottom circle
    int[] xs;
    int[] ys;
    arc = new Arc2D.Double(arcX, arcY + depth, pieArea.getWidth(), pieArea.getHeight() - depth, 0, 360, Arc2D.PIE);
    int categoryCount = arcList.size();
    for (int categoryIndex = 0; categoryIndex < categoryCount; categoryIndex++) {
        arc = (Arc2D.Double) arcList.get(categoryIndex);
        if (arc == null) {
            continue;
        }
        Comparable key = getSectionKey(categoryIndex);
        paint = lookupSectionPaint(key, false);
        outlinePaint = lookupSectionOutlinePaint(key, false);
        outlineStroke = lookupSectionOutlineStroke(key, false);
        g2.setPaint(paint);
        g2.fill(arc);
        g2.setPaint(outlinePaint);
        g2.setStroke(outlineStroke);
        g2.draw(arc);
        g2.setPaint(paint);
        Point2D p1 = arc.getStartPoint();
        // draw the height
        xs = new int[] { (int) arc.getCenterX(), (int) arc.getCenterX(), (int) p1.getX(), (int) p1.getX() };
        ys = new int[] { (int) arc.getCenterY(), (int) arc.getCenterY() - depth, (int) p1.getY() - depth, (int) p1.getY() };
        Polygon polygon = new Polygon(xs, ys, 4);
        g2.setPaint(java.awt.Color.lightGray);
        g2.fill(polygon);
        g2.setPaint(outlinePaint);
        g2.setStroke(outlineStroke);
        g2.draw(polygon);
        g2.setPaint(paint);
    }
    g2.setPaint(Color.gray);
    g2.fill(back);
    g2.fill(front);
    // cycle through once drawing only the sides at the back...
    int cat = 0;
    iterator = arcList.iterator();
    while (iterator.hasNext()) {
        Arc2D segment = (Arc2D) iterator.next();
        if (segment != null) {
            Comparable key = getSectionKey(cat);
            paint = lookupSectionPaint(key, false);
            outlinePaint = lookupSectionOutlinePaint(key, false);
            outlineStroke = lookupSectionOutlineStroke(key, false);
            drawSide(g2, pieArea, segment, front, back, paint, outlinePaint, outlineStroke, false, true);
        }
        cat++;
    }
    // cycle through again drawing only the sides at the front...
    cat = 0;
    iterator = arcList.iterator();
    while (iterator.hasNext()) {
        Arc2D segment = (Arc2D) iterator.next();
        if (segment != null) {
            Comparable key = getSectionKey(cat);
            paint = lookupSectionPaint(key, false);
            outlinePaint = lookupSectionOutlinePaint(key, false);
            outlineStroke = lookupSectionOutlineStroke(key, false);
            drawSide(g2, pieArea, segment, front, back, paint, outlinePaint, outlineStroke, true, false);
        }
        cat++;
    }
    g2.setClip(oldClip);
    // draw the sections at the top of the pie (and set up tooltips)...
    Arc2D upperArc;
    for (int sectionIndex = 0; sectionIndex < categoryCount; sectionIndex++) {
        arc = (Arc2D.Double) arcList.get(sectionIndex);
        if (arc == null) {
            continue;
        }
        upperArc = new Arc2D.Double(arcX, arcY, pieArea.getWidth(), pieArea.getHeight() - depth, arc.getAngleStart(), arc.getAngleExtent(), Arc2D.PIE);
        Comparable currentKey = (Comparable) sectionKeys.get(sectionIndex);
        paint = lookupSectionPaint(currentKey, true);
        outlinePaint = lookupSectionOutlinePaint(currentKey, false);
        outlineStroke = lookupSectionOutlineStroke(currentKey, false);
        g2.setPaint(paint);
        g2.fill(upperArc);
        g2.setStroke(outlineStroke);
        g2.setPaint(outlinePaint);
        g2.draw(upperArc);
        // add a tooltip for the section...
        if (info != null) {
            EntityCollection entities = info.getOwner().getEntityCollection();
            if (entities != null) {
                String tip = null;
                PieToolTipGenerator tipster = getToolTipGenerator();
                if (tipster != null) {
                    // @mgs: using the method's return value was missing
                    tip = tipster.generateToolTip(dataset, currentKey);
                }
                String url = null;
                if (getURLGenerator() != null) {
                    url = getURLGenerator().generateURL(dataset, currentKey, getPieIndex());
                }
                PieSectionEntity entity = new PieSectionEntity(upperArc, dataset, getPieIndex(), sectionIndex, currentKey, tip, url);
                entities.add(entity);
            }
        }
    }
    List keys = dataset.getKeys();
    Rectangle2D adjustedPlotArea = new Rectangle2D.Double(originalPlotArea.getX(), originalPlotArea.getY(), originalPlotArea.getWidth(), originalPlotArea.getHeight() - depth);
    if (getSimpleLabels()) {
        drawSimpleLabels(g2, keys, totalValue, adjustedPlotArea, linkArea, state);
    } else {
        drawLabels(g2, keys, totalValue, adjustedPlotArea, linkArea, state);
    }
    g2.setClip(savedClip);
    g2.setComposite(originalComposite);
    drawOutline(g2, originalPlotArea);
}