Example usage for org.jfree.data.general Series getItemCount

List of usage examples for org.jfree.data.general Series getItemCount

Introduction

In this page you can find the example usage for org.jfree.data.general Series getItemCount.

Prototype

public abstract int getItemCount();

Source Link

Document

Returns the number of data items in the series.

Usage

From source file:org.lmn.fc.frameworks.starbase.plugins.observatory.ui.tabs.charts.ChartHelper.java

/***********************************************************************************************
 * Transform a Domain Slider value to an index into the List of specified data items,
 * taking account that the List may not fully occupy the Domain.
 *
 * Series_position   Left   Right/*  w w w.ja va  2  s .  co  m*/
 *        |
 *        |  xxx     start   -1
 *        |
 *        |xxx       start   start
 *        |
 *       xxx         index   index
 *        |
 *     xxx|          end     end
 *        |
 *   xxx  |          -1      end
 *        |
 *
 * @param domainslidermin
 * @param domainslidermax
 * @param domainslidervalue
 * @param domainsliderindex
 * @param domainlowerbound
 * @param domainupperbound
 * @param datasettype
 * @param calendar
 * @param series
 * @param debug
 *
 * @return int
 */

public static int transformDomainSliderValueToSeriesIndex(final int domainslidermin, final int domainslidermax,
        final int domainslidervalue, final int domainsliderindex, final double domainlowerbound,
        final double domainupperbound, final DatasetType datasettype, final Calendar calendar,
        final Series series, final boolean debug) {
    final String SOURCE = "ChartHelper.transformDomainSliderValueToSeriesIndex() ";
    final int intIndex;

    switch (datasettype) {
    case XY: {
        final XYSeries xySeries;
        final XYDataItem dataItemFirst;
        final XYDataItem dataItemLast;
        final double dblItemFirstX;
        final double dblItemLastX;
        final double dblItemLastFirstX;
        final double dblDomainSliderX;

        xySeries = (XYSeries) series;
        dataItemFirst = xySeries.getDataItem(0);
        dataItemLast = xySeries.getDataItem(xySeries.getItemCount() - 1);

        dblItemFirstX = dataItemFirst.getXValue();
        dblItemLastX = dataItemLast.getXValue();

        // Diagnostic only
        dblItemLastFirstX = dblItemLastX - dblItemFirstX;

        dblDomainSliderX = calculateDomainSliderX(domainslidermin, domainslidermax, domainslidervalue,
                domainlowerbound, domainupperbound);

        LOGGER.debug(debug,
                SOURCE + "\n[domain.slider.min=" + domainslidermin + "]\n[domain.slider.max=" + domainslidermax
                        + "]\n[domain.slider.value=" + domainslidervalue + "]\n[domain.slider.index="
                        + domainsliderindex + "]\n[domain.lowerbound=" + domainlowerbound
                        + "]\n[domain.upperbound=" + domainupperbound + "]\n[domain.slider.x="
                        + dblDomainSliderX + "]\n[lastfirstitem.x=" + dblItemLastFirstX + "]\n[firstitem.x="
                        + dblItemFirstX + "]\n[lastitem.x=" + dblItemLastX + "]\n[dataset.type="
                        + datasettype.getName() + "]\n[series.itemcount=" + series.getItemCount() + "]");

        if (domainsliderindex == INDEX_LEFT) {
            if (dblDomainSliderX <= dblItemFirstX) {
                intIndex = 0;
                //System.out.println("LEFT <=");
            } else if (dblDomainSliderX == dblItemLastX) {
                intIndex = xySeries.getItemCount() - 1;
                //System.out.println("LEFT ==");
            } else if (dblDomainSliderX > dblItemLastX) {
                intIndex = -1;
                //System.out.println("LEFT >");
            } else {
                intIndex = findXYDataItemIndexForX(dblDomainSliderX, xySeries);
                //System.out.println("LEFT index");
            }
        } else if (domainsliderindex == INDEX_RIGHT) {
            if (dblDomainSliderX < dblItemFirstX) {
                intIndex = -1;
                //System.out.println("RIGHT <");
            } else if (dblDomainSliderX == dblItemFirstX) {
                intIndex = 0;
                //System.out.println("RIGHT ==");
            } else if (dblDomainSliderX >= dblItemLastX) {
                intIndex = xySeries.getItemCount() - 1;
                //System.out.println("RIGHT >=");
            } else {
                intIndex = findXYDataItemIndexForX(dblDomainSliderX, xySeries);
                //System.out.println("RIGHT index");
            }
        } else {
            // Do nothing, an Error
            LOGGER.error(SOURCE + "Invalid Domain Slider [index=" + domainsliderindex + "]");
            intIndex = -1;
        }

        break;
    }

    case TIMESTAMPED: {
        final TimeSeries timeSeries;
        final TimeSeriesDataItem dataItemFirst;
        final TimeSeriesDataItem dataItemLast;
        final double dblItemFirstMillis;
        final double dblItemLastMillis;
        final double dblItemLastFirstMillis;
        final double dblDomainSliderMillis;

        timeSeries = (TimeSeries) series;
        dataItemFirst = timeSeries.getDataItem(0);
        dataItemLast = timeSeries.getDataItem(timeSeries.getItemCount() - 1);

        dblItemFirstMillis = dataItemFirst.getPeriod().getFirstMillisecond(calendar);
        dblItemLastMillis = dataItemLast.getPeriod().getLastMillisecond(calendar);

        // Diagnostic only
        dblItemLastFirstMillis = dblItemLastMillis - dblItemFirstMillis;

        dblDomainSliderMillis = calculateDomainSliderMillis(domainslidermin, domainslidermax, domainslidervalue,
                domainlowerbound, domainupperbound, calendar, debug);
        LOGGER.debug(debug,
                SOURCE + "]\n\n[domain.slider.index=" + domainsliderindex + "]\n[domain.slider.value="
                        + domainslidervalue + "]\n[domain.slider.millis=" + (long) dblDomainSliderMillis

                        + "]\n\n[firstitem.millis.calendar=" + (long) dblItemFirstMillis
                        + "]\n[firstitem.millis.period=" + dataItemFirst.getPeriod().getFirstMillisecond()
                        + "]\n[lastitem.millis.calendar=" + (long) dblItemLastMillis
                        + "]\n[lastitem.millis.period=" + dataItemLast.getPeriod().getLastMillisecond()
                        + "]\n[lastfirstitem.millis=" + (long) dblItemLastFirstMillis

                        + "]\n\n[dataset.type=" + datasettype.getName() + "]\n[series.itemcount="
                        + series.getItemCount() + "]");

        if (domainsliderindex == INDEX_LEFT) {
            if (dblDomainSliderMillis <= dblItemFirstMillis) {
                intIndex = 0;
                LOGGER.debug(debug, SOURCE + "LEFT(slider) <= FIRST(calendar)");
            } else if (dblDomainSliderMillis == dblItemLastMillis) {
                intIndex = timeSeries.getItemCount() - 1;
                LOGGER.debug(debug, SOURCE + "LEFT(slider) == LAST(calendar)");
            } else if (dblDomainSliderMillis > dblItemLastMillis) {
                intIndex = -1;
                LOGGER.debug(debug, SOURCE + "LEFT(slider) > LAST(calendar)");
            } else {
                intIndex = findTimeSeriesIndexForMillis(dblDomainSliderMillis, timeSeries, calendar);
                LOGGER.debug(debug, SOURCE + "LEFT ok");
            }
        } else if (domainsliderindex == INDEX_RIGHT) {
            if (dblDomainSliderMillis < dblItemFirstMillis) {
                intIndex = -1;
                LOGGER.debug(debug, SOURCE + "RIGHT(slider) < FIRST(calendar)");
            } else if (dblDomainSliderMillis == dblItemFirstMillis) {
                intIndex = 0;
                LOGGER.debug(debug, SOURCE + "RIGHT(slider) == FIRST(calendar)");
            } else if (dblDomainSliderMillis >= dblItemLastMillis) {
                intIndex = timeSeries.getItemCount() - 1;
                LOGGER.debug(debug, SOURCE + "RIGHT(slider) >= LAST(calendar)");
            } else {
                intIndex = findTimeSeriesIndexForMillis(dblDomainSliderMillis, timeSeries, calendar);
                LOGGER.debug(debug, SOURCE + "RIGHT(slider) ok");
            }
        } else {
            // Do nothing, an Error
            LOGGER.error(SOURCE + "Invalid Domain Slider [domainslider.index=" + domainsliderindex + "]");
            intIndex = -1;
        }

        break;
    }

    default: {
        // Do nothing, an Error
        LOGGER.error(SOURCE + "Invalid DatasetType [type=" + datasettype.getName() + "]");
        intIndex = -1;
    }
    }

    LOGGER.debug(debug,
            SOURCE + "[series.item.index=" + intIndex + "] [series.item.count=" + series.getItemCount() + "]");
    LOGGER.debug(debug, Logger.CONSOLE_SEPARATOR_MINOR);

    return (intIndex);
}