Example usage for org.jfree.chart.renderer.xy XYItemRenderer setItemLabelGenerator

List of usage examples for org.jfree.chart.renderer.xy XYItemRenderer setItemLabelGenerator

Introduction

In this page you can find the example usage for org.jfree.chart.renderer.xy XYItemRenderer setItemLabelGenerator.

Prototype

public void setItemLabelGenerator(XYItemLabelGenerator generator);

Source Link

Document

Sets the item label generator for ALL series and sends a RendererChangeEvent to all registered listeners.

Usage

From source file:sim.app.sugarscape.Sugarscape.java

public void start() {
    super.start();
    agents_grid.clear();// w w w  .  j  a v  a 2 s.c o  m
    scape_grid.clear();
    //scape_grid = new ObjectGrid2D(gridWidth, gridHeight);
    sim.app.sugarscape.Agent agent;
    /* If the season rate is very large, it will be summer for all foreseable simulation runs in the north and winter
    in the south. Growback rates for each are set as parameters and normally default to 1 */
    north_season = SUMMER;
    south_season = WINTER;
    Steppable season_changer = new Steppable() {
        public void step(SimState state) {
            Sugarscape sugar = (Sugarscape) state;
            if (sugar.north_season == SUMMER) {
                sugar.north_season = WINTER;
                sugar.south_season = SUMMER;
            } else {
                sugar.north_season = SUMMER;
                sugar.south_season = WINTER;
            }
        }
    };

    MultiStep season_multi = new MultiStep(season_changer, season_rate, true);
    schedule.scheduleRepeating(Schedule.EPOCH, 3, season_multi, 1); //change seasons last in order

    if (agents_file != null) { //config file for setting up agents spatial config
        try {
            InputStream is = Class.forName(sim.app.sugarscape.Sugarscape.class.getCanonicalName())
                    .getClassLoader().getResourceAsStream(agents_file);
            InputStreamReader ir = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(ir);

            String line = br.readLine();
            int y = 0;
            int affiliation;
            String affil_code;
            while (line != null) {
                int x = 0;
                int size = line.length();
                while (x < size) {
                    affil_code = line.substring(x, x + 1);
                    affiliation = Integer.parseInt(affil_code);
                    if (affiliation != 0) {
                        agent = this.newAgent();
                        agents_grid.field[x][y] = agent; //,new Int2D(x,y));
                        agent.my_loc.x = x;
                        agent.my_loc.y = y;
                    }
                    x++;
                }
                line = br.readLine();
                y++;
                //System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else { //otherwise distribute randomly in space
        for (int a = 0; a < numAgents; a++) {
            createNewAgent();
        }
    }

    ArrayList rows = new ArrayList(50);
    for (int a = 0; a < resources; a++) {
        rows.clear();
        try {
            InputStream is = Class.forName(sim.app.sugarscape.Sugarscape.class.getCanonicalName())
                    .getClassLoader().getResourceAsStream(terrain_files[a]);
            InputStreamReader ir = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(ir);
            String line = br.readLine();
            while (line != null) {
                rows.add(line);
                line = br.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        int row_count = rows.size();
        int capacity;
        String max;
        int equator = row_count / 2;
        int hemisphere = NORTH;
        Object[][] all_objs = scape_grid.field;
        //Object[][] all_pollut = pollution_grid.field;
        for (int y = 0; y < gridHeight; y++) {
            if (y >= equator) {
                hemisphere = SOUTH;
            }
            StringBuffer sb = new StringBuffer((String) rows.get(y));
            int type;
            for (int x = 0; x < gridWidth; x++) {
                max = sb.substring(x, x + 1);
                capacity = Integer.parseInt(max);
                if (capacity > 4) { //terrain file has values of 0-4, and 0,5-8
                    type = SPICE;
                    capacity = capacity - 4;
                } else {
                    type = SUGAR;
                }
                if (all_objs[x][y] == null) {
                    Scape site = new Scape(x, y, hemisphere, pollution_diffusion, this);
                    site.setResource(type, capacity, 1,
                            capacity); /* idealy the growback rate, third param, should not be constant */
                    all_objs[x][y] = site;
                } else {
                    ((Scape) all_objs[x][y]).setResource(type, capacity, 1, capacity);
                }
            }
        }
    }
    this.initializeEnvironment();

    //set up charts
    avg_agent_vision.clear();
    lorenz_curve.clear();
    gini_coeff.clear();
    agents_series.clear();
    blue_agents.clear();
    red_agents.clear();
    trade_series.clear();

    if (stats_rate > 0) {
        Statistics stats = new Statistics(this, schedule, stats_out);
        MultiStep multi_lorenz = new MultiStep(stats, stats_rate, true);
        schedule.scheduleRepeating(Schedule.EPOCH, 4, multi_lorenz, 1);
        stats.step(this);
    }
    //calculate and output frequency count for metabolic 'bins'
    //that is the total metabolism for each each across the population
    Steppable metabolism_bins_updater = new Steppable() {
        Histogram h = new Histogram("Metabolism", "Vision", 1 + metabolic_sugar + metabolic_spice, 5);

        public void step(SimState state) {
            //agents_grid.

            Bag all = null; //agents_grid.getAllObjects();
            int size = all.size();
            int total = 0;
            Object[] all_obj = all.objs;
            h.zero();
            for (int a = 0; a < size; a++) {
                Agent ag = (Agent) all_obj[a];
                total = ag.metabolic_rate_spice + ag.metabolic_rate_sugar;
                h.bins[total] = h.bins[total] + 1;
                h.bins_assoc[total] = h.bins_assoc[total] + ag.vision;
            }
            h.render();
            System.out.println(size + " = size, " + (state.schedule.time() + 1) + " = steps.");

        }
    };

    if (print_metabolism_bins) {
        MultiStep multi_metabolism_bins = new MultiStep(metabolism_bins_updater, metabolism_bins_freq, true);
        schedule.scheduleRepeating(Schedule.EPOCH, 6, multi_metabolism_bins, 1);
        multi_metabolism_bins.step(this);
    }

    //TO DO: Restore this
    if (logger != null) {
        MultiStep multi_logger = null; //new MultiStep(logger, log_frequency, true);
        //use order 4 along with statistics steppable
        //System.out.println("Logging "+ logger.grids.size() + " grids.");
        schedule.scheduleRepeating(Schedule.EPOCH, 4, multi_logger, 1);
        //Thread t = new Thread(logger);
        //t.start();
    }

    Steppable chart_updater = new Steppable() {
        private static final int BINS = 10;
        private float total;
        private float wealth_sugar_total;
        private double[] ages;

        public void step(SimState state) {

            Bag all = null; //agents_grid.getAllObjects();
            int size = active_agents_count;
            double[] values = null;
            if (size != 0) { /* what if there are zero agents? */
                values = new double[size];
            } else {
                values = new double[1];
                values[0] = 0;
            }
            total = 0;
            wealth_sugar_total = 0;
            if (age_chart_on) {
                ages = new double[size];
            }
            Iterator<Agent> i = active_agents.iterator();
            int a = 0;
            while (i.hasNext()) {
                Agent agent = i.next();
                values[a] = agent.wealth_sugar;
                wealth_sugar_total = wealth_sugar_total + agent.wealth_sugar;
                if (age_chart_on) {
                    ages[a] = agent.age;
                }
                a++;
            }

            if (age_chart_on) {
                age_hist_dataset = new HistogramDataset();
                age_hist_dataset.addSeries(Double.toString(state.schedule.time()), ages, 10);
                XYPlot xy = ((Sugarscape) state).age_histo_chart.getXYPlot();
                xy.setDataset(age_hist_dataset);
            }

            if (wealth_chart_on) {
                dataset = new HistogramDataset();
                dataset.addSeries(Double.toString(state.schedule.time()), values, 10);
                XYPlot xy = ((Sugarscape) state).chart4.getXYPlot();
                xy.setDataset(dataset);
                XYItemRenderer r = xy.getRenderer();
                XYItemLabelGenerator xylg = new StandardXYItemLabelGenerator("{2}", new DecimalFormat("0.00"),
                        new DecimalFormat("0.00"));
                r.setItemLabelGenerator(xylg);
                r.setItemLabelsVisible(true);
            }
        }
    };
    // Schedule the agent to update the chart
    if (chart_display) {
        MultiStep multi_chart = new MultiStep(chart_updater, chart_rate, true);
        schedule.scheduleRepeating(Schedule.EPOCH, 6, multi_chart, 1);
        chart_updater.step(this);
    }
}

From source file:com.naryx.tagfusion.cfm.tag.awt.cfCHART.java

private XYPlot getXYPlot(List<cfCHARTSERIESData> series, String xAxisTitle, String yAxisTitle,
        String labelFormat, boolean bShowMarkers, int markerSize, boolean bShow3D, String tipStyle,
        String drillDownUrl, int xOffset, int yOffset, int yAxisUnits, String seriesPlacement, int height,
        int gridLines) throws cfmRunTimeException {
    // Create an XY plot
    XYPlot plot = new XYPlot();
    ValueAxis domainAxis;/* w w  w. ja  va2  s  .  com*/

    if (series.get(0).getSeriesDataType() == cfCHARTSERIESData.XY_NUMERIC_SERIES) {
        if (bShow3D)
            domainAxis = new NumberAxis3D(xAxisTitle);
        else
            domainAxis = new NumberAxis(xAxisTitle);
    } else {
        domainAxis = new DateAxis(xAxisTitle);
    }
    plot.setDomainAxis(domainAxis);

    ValueAxis valueAxis;
    DateFormat dateFormat = null;
    NumberFormat numberFormat = null;
    if (labelFormat.equals("date")) {
        valueAxis = new DateAxis(yAxisTitle);
        dateFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
        ((DateAxis) valueAxis).setDateFormatOverride(dateFormat);
    } else {
        if (bShow3D)
            valueAxis = new NumberAxis3D(yAxisTitle);
        else
            valueAxis = new NumberAxis(yAxisTitle);
        if (labelFormat.equals("currency")) {
            ((NumberAxis) valueAxis).setNumberFormatOverride(NumberFormat.getCurrencyInstance());
            numberFormat = NumberFormat.getCurrencyInstance();
        } else if (labelFormat.equals("percent")) {
            numberFormat = NumberFormat.getPercentInstance();
            numberFormat.setMaximumFractionDigits(3); // without this change .11443
                                                      // would be displayed as 11%
                                                      // instead of 11.443%
            ((NumberAxis) valueAxis).setNumberFormatOverride(numberFormat);
        } else {
            numberFormat = NumberFormat.getInstance();
        }

        if (yAxisUnits != 0)
            ((NumberAxis) valueAxis).setTickUnit(new NumberTickUnit(yAxisUnits));
    }
    plot.setRangeAxis(valueAxis);

    // Add a dataset and renderer for each series
    int barChartDatasetIndex = -1;
    int hBarChartDatasetIndex = -1;
    int num = 0;
    MinMaxData minMax = new MinMaxData();
    for (int i = 0; i < series.size(); i++) {
        cfCHARTSERIESData seriesData = series.get(i);
        XYSeriesCollection dataset;
        if ((barChartDatasetIndex != -1) && (seriesData.getType().equals("bar"))) {
            dataset = (XYSeriesCollection) plot.getDataset(barChartDatasetIndex);

            addSeriesDataToDataset(seriesData, dataset, minMax);

            // Set the paint style for this series
            setPaintStyle(seriesData.getPaintStyle(), plot.getRenderer(barChartDatasetIndex),
                    dataset.getSeriesCount() - 1, height);

            // Add the color list for this series to the custom color renderer
            CustomColorRenderer cr = (CustomColorRenderer) plot.getRenderer(barChartDatasetIndex);
            cr.addColors(getColorList(seriesData));

            continue;
        } else if ((hBarChartDatasetIndex != -1) && (seriesData.getType().equals("horizontalbar"))) {
            dataset = (XYSeriesCollection) plot.getDataset(hBarChartDatasetIndex);

            addSeriesDataToDataset(seriesData, dataset, minMax);

            // Set the paint style for this series
            setPaintStyle(seriesData.getPaintStyle(), plot.getRenderer(hBarChartDatasetIndex),
                    dataset.getSeriesCount() - 1, height);

            // Add the color list for this series to the custom color renderer
            CustomColorRenderer cr = (CustomColorRenderer) plot.getRenderer(hBarChartDatasetIndex);
            cr.addColors(getColorList(seriesData));

            continue;
        } else {
            dataset = new XYSeriesCollection();

            addSeriesDataToDataset(seriesData, dataset, minMax);
        }

        plot.setDataset(num, dataset);

        XYItemRenderer renderer = null;
        if (seriesData.getType().equals("bar")) {
            plot.setOrientation(PlotOrientation.VERTICAL);
            renderer = getXYBarRenderer(seriesPlacement, bShow3D, xOffset, yOffset, getColorList(seriesData));
            ItemLabelPosition position1 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12,
                    TextAnchor.BOTTOM_CENTER);
            renderer.setPositiveItemLabelPosition(position1);
            ItemLabelPosition position2 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE6,
                    TextAnchor.TOP_CENTER);
            renderer.setNegativeItemLabelPosition(position2);
            ((XYBarRenderer) renderer).setMargin(0.2); // The margin between each
                                                       // category

            barChartDatasetIndex = num;
        } else if (seriesData.getType().equals("horizontalbar")) {
            plot.setOrientation(PlotOrientation.HORIZONTAL);
            plot.setRangeAxisLocation(AxisLocation.BOTTOM_OR_LEFT);
            renderer = getXYBarRenderer(seriesPlacement, bShow3D, xOffset, yOffset, getColorList(seriesData));
            ItemLabelPosition position1 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE3,
                    TextAnchor.CENTER_LEFT);
            renderer.setPositiveItemLabelPosition(position1);
            ItemLabelPosition position2 = new ItemLabelPosition(ItemLabelAnchor.OUTSIDE9,
                    TextAnchor.CENTER_RIGHT);
            renderer.setNegativeItemLabelPosition(position2);
            ((XYBarRenderer) renderer).setMargin(0.2); // The margin between each
                                                       // category

            hBarChartDatasetIndex = num;
        } else if (seriesData.getType().equals("line")) {
            renderer = new XYLineAndShapeRenderer(true, false);

            // Enable/Disable displaying of markers
            ((XYLineAndShapeRenderer) renderer).setShapesVisible(bShowMarkers);

            // Set the shape of the markers based on the markerSize value
            ((XYLineAndShapeRenderer) renderer).setShape(getMarker(seriesData.getMarkerStyle(), markerSize));
        } else if (seriesData.getType().equals("area")) {
            renderer = new CustomXYAreaRenderer();
        } else if (seriesData.getType().equals("step")) {
            renderer = new CustomXYStepRenderer();
        } else if (seriesData.getType().equals("scatter")) {
            renderer = new XYLineAndShapeRenderer(false, true);

            // Set the shape of the markers based on the markerSize value
            ((XYLineAndShapeRenderer) renderer).setShape(getMarker(seriesData.getMarkerStyle(), markerSize));
        }

        if (!tipStyle.equals("none")) {
            if (series.get(0).getSeriesDataType() == cfCHARTSERIESData.XY_DATE_SERIES) {
                renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator("{0}: {1}",
                        DateFormat.getInstance(), DateFormat.getInstance()));
            } else {
                if (dateFormat != null)
                    renderer.setBaseToolTipGenerator(
                            new StandardXYToolTipGenerator("{0}: {2}", dateFormat, dateFormat));
                else
                    renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator("{0}: ({1}, {2})",
                            numberFormat, NumberFormat.getInstance()));
            }
        }

        if (drillDownUrl != null) {
            if (dateFormat != null)
                renderer.setURLGenerator(
                        new com.newatlanta.bluedragon.XYURLGenerator(drillDownUrl, dateFormat));
            else
                renderer.setURLGenerator(
                        new com.newatlanta.bluedragon.XYURLGenerator(drillDownUrl, numberFormat));
        }

        if (seriesData.getSeriesColor() != null)
            renderer.setSeriesPaint(0, convertStringToColor(seriesData.getSeriesColor()));

        String dataLabelStyle = seriesData.getDataLabelStyle();
        if (labelFormat.equals("date")) {
            if (dataLabelStyle.equals("none")) {
                renderer.setItemLabelsVisible(false);
            } else {
                setXYItemLabelsData(renderer, seriesData);
                if (dataLabelStyle.equals("value"))
                    renderer.setItemLabelGenerator(
                            new StandardXYItemLabelGenerator("{2}", dateFormat, dateFormat));
                else if (dataLabelStyle.equals("rowlabel"))
                    renderer.setItemLabelGenerator(new StandardXYItemLabelGenerator("{0}",
                            NumberFormat.getInstance(), NumberFormat.getInstance()));
                else if (dataLabelStyle.equals("columnlabel"))
                    renderer.setItemLabelGenerator(new StandardXYItemLabelGenerator("{1}",
                            NumberFormat.getInstance(), NumberFormat.getInstance()));
                else if (dataLabelStyle.equals("pattern"))
                    renderer.setItemLabelGenerator(new XYItemLabelGenerator("{2}", dateFormat, dateFormat));
                else
                    renderer.setItemLabelGenerator(
                            new XYItemLabelGenerator(dataLabelStyle, dateFormat, dateFormat));
            }
        } else {
            if (dataLabelStyle.equals("none")) {
                renderer.setItemLabelsVisible(false);
            } else {
                setXYItemLabelsData(renderer, seriesData);
                if (dataLabelStyle.equals("value")) {

                    renderer.setItemLabelGenerator(
                            new StandardXYItemLabelGenerator("{2}", numberFormat, numberFormat));

                } else if (dataLabelStyle.equals("rowlabel")) {

                    renderer.setItemLabelGenerator(
                            new StandardXYItemLabelGenerator("{0}", numberFormat, numberFormat));

                } else if (dataLabelStyle.equals("columnlabel")) {

                    if (series.get(0).getSeriesDataType() == cfCHARTSERIESData.XY_DATE_SERIES) {
                        renderer.setItemLabelGenerator(new StandardXYItemLabelGenerator("{1}",
                                SimpleDateFormat.getInstance(), NumberFormat.getInstance()));
                    } else {
                        renderer.setItemLabelGenerator(new StandardXYItemLabelGenerator("{1}",
                                NumberFormat.getInstance(), NumberFormat.getInstance()));
                    }

                } else if (dataLabelStyle.equals("pattern")) {

                    if (series.get(0).getSeriesDataType() == cfCHARTSERIESData.XY_DATE_SERIES) {
                        renderer.setItemLabelGenerator(new XYItemLabelGenerator("{1} {2} ({3} of {4})",
                                SimpleDateFormat.getInstance(), numberFormat));
                    } else {
                        renderer.setItemLabelGenerator(new XYItemLabelGenerator("{1} {2} ({3} of {4})",
                                NumberFormat.getInstance(), numberFormat));
                    }

                } else {
                    renderer.setItemLabelGenerator(
                            new XYItemLabelGenerator(dataLabelStyle, NumberFormat.getInstance(), numberFormat));
                }
            }
        }

        // Add the renderer to the plot.
        // NOTE: this must be done before the setPaintStyle() call so the
        // DrawingSupplier object
        // will be set up properly for the generation of default colors.
        plot.setRenderer(num, renderer);

        // Set the paint style for this series (series 0)
        if (seriesData.getType().equals("bar") || seriesData.getType().equals("horizontalbar")
                || seriesData.getType().equals("area"))
            setPaintStyle(seriesData.getPaintStyle(), renderer, 0, height);

        num++;
    }

    // If gridLines was specified then we need to calculate the yAxisUnits
    if ((gridLines != -1) && (valueAxis instanceof NumberAxis)) {
        // Calculate the yAxisUnits we need to use to create the number of
        // gridLines
        yAxisUnits = calculateYAxisUnits(gridLines, minMax);

        // Set the yAxisUnits
        ((NumberAxis) valueAxis).setTickUnit(new NumberTickUnit(yAxisUnits));
    }

    return plot;
}