Example usage for org.jfree.data.category CategoryDataset getColumnCount

Introduction

In this page you can find the example usage for org.jfree.data.category CategoryDataset getColumnCount.

Prototype

public int getColumnCount();

Source Link

Document

Returns the number of columns in the table.

Usage

From source file:KIDLYRenderer.java

/**
 * Calculates the bar width and stores it in the renderer state.
 *
 * @param plot  the plot./*w  w  w. j a va  2 s . co m*/
 * @param dataArea  the data area.
 * @param rendererIndex  the renderer index.
 * @param state  the renderer state.
 */
protected void calculateBarWidth(CategoryPlot plot, Rectangle2D dataArea, int rendererIndex,
        CategoryItemRendererState state) {

    CategoryAxis domainAxis = getDomainAxis(plot, rendererIndex);
    CategoryDataset dataset = plot.getDataset(rendererIndex);
    if (dataset != null) {
        int columns = dataset.getColumnCount();
        int rows = state.getVisibleSeriesCount() >= 0 ? state.getVisibleSeriesCount() : dataset.getRowCount();
        double space = 0.0;
        PlotOrientation orientation = plot.getOrientation();
        if (orientation == PlotOrientation.HORIZONTAL) {
            space = dataArea.getHeight();
        } else if (orientation == PlotOrientation.VERTICAL) {
            space = dataArea.getWidth();
        }
        double maxWidth = space * getMaximumBarWidth();
        double categoryMargin = 0.0;
        double currentItemMargin = 0.0;
        if (columns > 1) {
            categoryMargin = domainAxis.getCategoryMargin();
        }
        if (rows > 1) {
            currentItemMargin = getItemMargin();
        }
        double used = space * (1 - domainAxis.getLowerMargin() - domainAxis.getUpperMargin() - categoryMargin
                - currentItemMargin);
        if ((rows * columns) > 0) {
            state.setBarWidth(Math.min(used / (rows * columns), maxWidth));
        } else {
            state.setBarWidth(Math.min(used, maxWidth));
        }
    }
}

---

From source file:ubic.gemma.web.controller.expression.experiment.ExpressionExperimentQCController.java

private boolean writePCAScree(OutputStream os, SVDValueObject svdo) throws Exception {
    /*/*from w  ww .  ja  va 2 s  .  com*/
     * Make a scree plot.
     */
    CategoryDataset series = this.getPCAScree(svdo);

    if (series.getColumnCount() == 0) {
        return false;
    }
    int MAX_COMPONENTS_FOR_SCREE = 10;
    ChartFactory.setChartTheme(StandardChartTheme.createLegacyTheme());
    JFreeChart chart = ChartFactory.createBarChart("", "Component (up to" + MAX_COMPONENTS_FOR_SCREE + ")",
            "Fraction of var.", series, PlotOrientation.VERTICAL, false, false, false);

    BarRenderer renderer = (BarRenderer) chart.getCategoryPlot().getRenderer();
    renderer.setBasePaint(Color.white);
    renderer.setShadowVisible(false);
    chart.getCategoryPlot().setRangeGridlinesVisible(false);
    chart.getCategoryPlot().setDomainGridlinesVisible(false);
    ChartUtilities.writeChartAsPNG(os, chart, ExpressionExperimentQCController.DEFAULT_QC_IMAGE_SIZE_PX,
            ExpressionExperimentQCController.DEFAULT_QC_IMAGE_SIZE_PX);
    return true;
}

---

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

/**
 * Returns <code>true</code> if the dataset is empty (or <code>null</code>),
 * and <code>false</code> otherwise.
 *
 * @param dataset  the dataset (<code>null</code> permitted).
 *
 * @return A boolean./*from   ww  w  .j a v  a 2s.  c om*/
 */
public static boolean isEmptyOrNull(CategoryDataset dataset) {

    if (dataset == null) {
        return true;
    }

    int rowCount = dataset.getRowCount();
    int columnCount = dataset.getColumnCount();
    if (rowCount == 0 || columnCount == 0) {
        return true;
    }

    for (int r = 0; r < rowCount; r++) {
        for (int c = 0; c < columnCount; c++) {
            if (dataset.getValue(r, c) != null) {
                return false;
            }

        }
    }

    return true;

}

---

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

/**
 * Returns the maximum value in the dataset range, assuming that values in
 * each category are "stacked".//from  ww w . j  a v  a2  s. com
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The maximum value (possibly {@code null}).
 *
 * @see #findMinimumStackedRangeValue(CategoryDataset)
 */
public static Number findMaximumStackedRangeValue(CategoryDataset dataset) {
    Args.nullNotPermitted(dataset, "dataset");
    Number result = null;
    boolean hasValidData = false;
    double maximum = 0.0;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double total = 0.0;
        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) {
                    total = total + value;
                }
            }
        }
        maximum = Math.max(maximum, total);
    }
    if (hasValidData) {
        result = new Double(maximum);
    }
    return result;
}

---

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

/**
 * Returns the minimum value in the dataset range, assuming that values in
 * each category are "stacked".//from  w w w .  j ava  2s  .co m
 *
 * @param dataset  the dataset ({@code null} not permitted).
 *
 * @return The minimum value.
 *
 * @see #findMaximumStackedRangeValue(CategoryDataset)
 */
public static Number findMinimumStackedRangeValue(CategoryDataset dataset) {
    Args.nullNotPermitted(dataset, "dataset");
    Number result = null;
    boolean hasValidData = false;
    double minimum = 0.0;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double total = 0.0;
        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) {
                    total = total + value;
                    // '+', remember value is negative
                }
            }
        }
        minimum = Math.min(minimum, total);
    }
    if (hasValidData) {
        result = new Double(minimum);
    }
    return result;
}

---

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

/**
 * Returns the maximum value in the dataset range, assuming that values in
 * each category are "stacked".//from  w  w  w .j  a va  2s .  c  o  m
 *
 * @param dataset  the dataset (<code>null</code> not permitted).
 *
 * @return The maximum value (possibly <code>null</code>).
 *
 * @see #findMinimumStackedRangeValue(CategoryDataset)
 */
public static Number findMaximumStackedRangeValue(CategoryDataset dataset) {
    ParamChecks.nullNotPermitted(dataset, "dataset");
    Number result = null;
    boolean hasValidData = false;
    double maximum = 0.0;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double total = 0.0;
        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) {
                    total = total + value;
                }
            }
        }
        maximum = Math.max(maximum, total);
    }
    if (hasValidData) {
        result = new Double(maximum);
    }
    return result;
}

---

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

/**
 * Returns the minimum value in the dataset range, assuming that values in
 * each category are "stacked".//from  w  w w .j ava  2 s .c  o  m
 *
 * @param dataset  the dataset (<code>null</code> not permitted).
 *
 * @return The minimum value.
 *
 * @see #findMaximumStackedRangeValue(CategoryDataset)
 */
public static Number findMinimumStackedRangeValue(CategoryDataset dataset) {
    ParamChecks.nullNotPermitted(dataset, "dataset");
    Number result = null;
    boolean hasValidData = false;
    double minimum = 0.0;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double total = 0.0;
        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) {
                    total = total + value;
                    // '+', remember value is negative
                }
            }
        }
        minimum = Math.min(minimum, total);
    }
    if (hasValidData) {
        result = new Double(minimum);
    }
    return result;
}

---

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 ({@code null} not permitted).
 * @param base  the base value for the bars.
 *
 * @return The range ({@code null} if the dataset contains no values).
 *//*from   w  w  w .  j a v  a 2s.c  om*/
public static Range findStackedRangeBounds(CategoryDataset dataset, double base) {
    Args.nullNotPermitted(dataset, "dataset");
    Range result = null;
    double minimum = Double.POSITIVE_INFINITY;
    double maximum = Double.NEGATIVE_INFINITY;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double positive = base;
        double negative = base;
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                double value = number.doubleValue();
                if (value > 0.0) {
                    positive = positive + value;
                }
                if (value < 0.0) {
                    negative = negative + value;
                    // '+', remember value is negative
                }
            }
        }
        minimum = Math.min(minimum, negative);
        maximum = Math.max(maximum, positive);
    }
    if (minimum <= maximum) {
        result = new Range(minimum, maximum);
    }
    return result;

}

---

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

/**
 * Iterates over the data item of the category dataset to find
 * the range bounds./*from   ww w  .  j  av  a2 s  .c o  m*/
 *
 * @param dataset  the dataset (<code>null</code> not permitted).
 * @param includeInterval  a flag that determines whether or not the
 *                         y-interval is taken into account.
 *
 * @return The range (possibly <code>null</code>).
 *
 * @since 1.0.10
 */
public static Range iterateRangeBounds(CategoryDataset dataset, boolean includeInterval) {
    double minimum = Double.POSITIVE_INFINITY;
    double maximum = Double.NEGATIVE_INFINITY;
    int rowCount = dataset.getRowCount();
    int columnCount = dataset.getColumnCount();
    if (includeInterval && dataset instanceof IntervalCategoryDataset) {
        // handle the special case where the dataset has y-intervals that
        // we want to measure
        IntervalCategoryDataset icd = (IntervalCategoryDataset) dataset;
        Number value, lvalue, uvalue;
        for (int row = 0; row < rowCount; row++) {
            for (int column = 0; column < columnCount; column++) {
                value = icd.getValue(row, column);
                double v;
                if ((value != null) && !Double.isNaN(v = value.doubleValue())) {
                    minimum = Math.min(v, minimum);
                    maximum = Math.max(v, maximum);
                }
                lvalue = icd.getStartValue(row, column);
                if (lvalue != null && !Double.isNaN(v = lvalue.doubleValue())) {
                    minimum = Math.min(v, minimum);
                    maximum = Math.max(v, maximum);
                }
                uvalue = icd.getEndValue(row, column);
                if (uvalue != null && !Double.isNaN(v = uvalue.doubleValue())) {
                    minimum = Math.min(v, minimum);
                    maximum = Math.max(v, maximum);
                }
            }
        }
    } else {
        // handle the standard case (plain CategoryDataset)
        for (int row = 0; row < rowCount; row++) {
            for (int column = 0; column < columnCount; column++) {
                Number value = dataset.getValue(row, column);
                if (value != null) {
                    double v = value.doubleValue();
                    if (!Double.isNaN(v)) {
                        minimum = Math.min(minimum, v);
                        maximum = Math.max(maximum, v);
                    }
                }
            }
        }
    }
    if (minimum == Double.POSITIVE_INFINITY) {
        return null;
    } else {
        return new Range(minimum, maximum);
    }
}

---

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 (<code>null</code> not permitted).
 * @param base  the base value for the bars.
 *
 * @return The range (<code>null</code> if the dataset contains no values).
 *//*from  ww  w . j  av  a  2s .c  o  m*/
public static Range findStackedRangeBounds(CategoryDataset dataset, double base) {
    ParamChecks.nullNotPermitted(dataset, "dataset");
    Range result = null;
    double minimum = Double.POSITIVE_INFINITY;
    double maximum = Double.NEGATIVE_INFINITY;
    int categoryCount = dataset.getColumnCount();
    for (int item = 0; item < categoryCount; item++) {
        double positive = base;
        double negative = base;
        int seriesCount = dataset.getRowCount();
        for (int series = 0; series < seriesCount; series++) {
            Number number = dataset.getValue(series, item);
            if (number != null) {
                double value = number.doubleValue();
                if (value > 0.0) {
                    positive = positive + value;
                }
                if (value < 0.0) {
                    negative = negative + value;
                    // '+', remember value is negative
                }
            }
        }
        minimum = Math.min(minimum, negative);
        maximum = Math.max(maximum, positive);
    }
    if (minimum <= maximum) {
        result = new Range(minimum, maximum);
    }
    return result;

}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »