Example usage for org.jfree.data KeyToGroupMap getGroupCount

Introduction

In this page you can find the example usage for org.jfree.data KeyToGroupMap getGroupCount.

Prototype

public int getGroupCount() 

Source Link

Document

Returns the number of groups in the map.

Usage

From source file:net.sf.dynamicreports.test.jasper.chart.GroupedStackedBarChartData3Test.java

private void testMap(JFreeChart chart, String... groups) {
    GroupedStackedBarRenderer renderer = (GroupedStackedBarRenderer) chart.getCategoryPlot().getRenderer();
    try {//ww w .j a  va  2s. c o  m
        Field field = renderer.getClass().getDeclaredField("seriesToGroupMap");
        field.setAccessible(true);
        KeyToGroupMap map = (KeyToGroupMap) field.get(renderer);
        Assert.assertEquals("map", groups.length, map.getGroupCount());
        List<?> groups2 = map.getGroups();
        for (int i = 0; i < groups2.size(); i++) {
            Assert.assertEquals("map", groups[i], groups2.get(i));
        }
    } catch (Exception e) {
        e.printStackTrace();
        Assert.fail(e.getMessage());
    }
}

---

From source file:org.jfree.data.KeyToGroupMapTest.java

/**
 * Tests that the getGroupCount() method returns the correct values under
 * various circumstances.//from w w  w . ja va2 s  . c o  m
 */
@Test
public void testGroupCount() {
    KeyToGroupMap m1 = new KeyToGroupMap("Default Group");

    // a new map always has 1 group (the default group)
    assertEquals(1, m1.getGroupCount());

    // if the default group is not mapped to, it should still count towards
    // the group count...
    m1.mapKeyToGroup("C1", "G1");
    assertEquals(2, m1.getGroupCount());

    // now when the default group is mapped to, it shouldn't increase the
    // group count...
    m1.mapKeyToGroup("C2", "Default Group");
    assertEquals(2, m1.getGroupCount());

    // complicate things a little...
    m1.mapKeyToGroup("C3", "Default Group");
    m1.mapKeyToGroup("C4", "G2");
    m1.mapKeyToGroup("C5", "G2");
    m1.mapKeyToGroup("C6", "Default Group");
    assertEquals(3, m1.getGroupCount());

    // now overwrite group "G2"...
    m1.mapKeyToGroup("C4", "G1");
    m1.mapKeyToGroup("C5", "G1");
    assertEquals(2, m1.getGroupCount());
}

---

From source file:org.jfree.data.general.DatasetUtils.java

/**
 * Returns the minimum and maximum values for the dataset's range
 * (y-values), assuming that the series in one category are stacked.
 *
 * @param dataset  the dataset.//from w ww  . j  a  va2 s  .  com
 * @param map  a structure that maps series to groups.
 *
 * @return The value range ({@code null} if the dataset contains no
 *         values).
 */
public static Range findStackedRangeBounds(CategoryDataset dataset, KeyToGroupMap map) {
    Args.nullNotPermitted(dataset, "dataset");
    boolean hasValidData = false;
    Range result = null;

    // create an array holding the group indices for each series...
    int[] groupIndex = new int[dataset.getRowCount()];
    for (int i = 0; i < dataset.getRowCount(); i++) {
        groupIndex[i] = map.getGroupIndex(map.getGroup(dataset.getRowKey(i)));
    }

    // minimum and maximum for each group...
    int groupCount = map.getGroupCount();
    double[] minimum = new double[groupCount];
    double[] maximum = new double[groupCount];

    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double[] positive = new double[groupCount];
        double[] negative = new double[groupCount];
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                hasValidData = true;
                double value = number.doubleValue();
                if (value > 0.0) {
                    positive[groupIndex[series]] = positive[groupIndex[series]] + value;
                }
                if (value < 0.0) {
                    negative[groupIndex[series]] = negative[groupIndex[series]] + value;
                    // '+', remember value is negative
                }
            }
        }
        for (int g = 0; g < groupCount; g++) {
            minimum[g] = Math.min(minimum[g], negative[g]);
            maximum[g] = Math.max(maximum[g], positive[g]);
        }
    }
    if (hasValidData) {
        for (int j = 0; j < groupCount; j++) {
            result = Range.combine(result, new Range(minimum[j], maximum[j]));
        }
    }
    return result;
}

---

From source file:org.jfree.data.general.DatasetUtilities.java

/**
 * Returns the minimum and maximum values for the dataset's range
 * (y-values), assuming that the series in one category are stacked.
 *
 * @param dataset  the dataset./*from w w  w .j a v  a  2s.c o  m*/
 * @param map  a structure that maps series to groups.
 *
 * @return The value range (<code>null</code> if the dataset contains no
 *         values).
 */
public static Range findStackedRangeBounds(CategoryDataset dataset, KeyToGroupMap map) {
    ParamChecks.nullNotPermitted(dataset, "dataset");
    boolean hasValidData = false;
    Range result = null;

    // create an array holding the group indices for each series...
    int[] groupIndex = new int[dataset.getRowCount()];
    for (int i = 0; i < dataset.getRowCount(); i++) {
        groupIndex[i] = map.getGroupIndex(map.getGroup(dataset.getRowKey(i)));
    }

    // minimum and maximum for each group...
    int groupCount = map.getGroupCount();
    double[] minimum = new double[groupCount];
    double[] maximum = new double[groupCount];

    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double[] positive = new double[groupCount];
        double[] negative = new double[groupCount];
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                hasValidData = true;
                double value = number.doubleValue();
                if (value > 0.0) {
                    positive[groupIndex[series]] = positive[groupIndex[series]] + value;
                }
                if (value < 0.0) {
                    negative[groupIndex[series]] = negative[groupIndex[series]] + value;
                    // '+', remember value is negative
                }
            }
        }
        for (int g = 0; g < groupCount; g++) {
            minimum[g] = Math.min(minimum[g], negative[g]);
            maximum[g] = Math.max(maximum[g], positive[g]);
        }
    }
    if (hasValidData) {
        for (int j = 0; j < groupCount; j++) {
            result = Range.combine(result, new Range(minimum[j], maximum[j]));
        }
    }
    return result;
}

---