Example usage for org.jfree.data.xy XYDataItem getXValue

List of usage examples for org.jfree.data.xy XYDataItem getXValue

  1. HOME
  2. Java
  3. org.jfree
  4. org.jfree.data.xy.*
  5. XYDataItem
  6. getXValue

Introduction

In this page you can find the example usage for org.jfree.data.xy XYDataItem getXValue.

Prototype

public double getXValue()

Source Link

Document

Returns the x-value as a double primitive.

Usage

From source file:org.jfree.data.xy.XYSeries.java

/**
 * Updates the cached values for the minimum and maximum data values.
 *
 * @param item  the item added (<code>null</code> not permitted).
 *
 * @since 1.0.13//from  w  w w  .  jav  a2  s  . co  m
 */
private void updateBoundsForAddedItem(XYDataItem item) {
    double x = item.getXValue();
    this.minX = minIgnoreNaN(this.minX, x);
    this.maxX = maxIgnoreNaN(this.maxX, x);
    if (item.getY() != null) {
        double y = item.getYValue();
        this.minY = minIgnoreNaN(this.minY, y);
        this.maxY = maxIgnoreNaN(this.maxY, y);
    }
}

From source file:org.esa.snap.rcp.statistics.ScatterPlotPanel.java

private XYIntervalSeries computeAcceptableDeviationData(double lowerBound, double upperBound) {
    final XYSeries identity = DatasetUtilities.sampleFunction2DToSeries(x -> x, lowerBound, upperBound, 100,
            "1:1 line");
    final XYIntervalSeries xyIntervalSeries = new XYIntervalSeries(identity.getKey());
    for (int i = 0; i < identity.getItemCount(); i++) {
        XYDataItem item = identity.getDataItem(i);
        final double x = item.getXValue();
        final double y = item.getYValue();
        if (scatterPlotModel.showAcceptableDeviation) {
            final double acceptableDeviation = scatterPlotModel.acceptableDeviationInterval;
            final double xOff = acceptableDeviation * x / 100;
            final double yOff = acceptableDeviation * y / 100;
            xyIntervalSeries.add(x, x - xOff, x + xOff, y, y - yOff, y + yOff);
        } else {//w  w  w  . j  a v  a  2s  . c  o  m
            xyIntervalSeries.add(x, x, x, y, y, y);
        }
    }
    return xyIntervalSeries;
}

From source file:org.esa.snap.rcp.statistics.ScatterPlotPanel.java

private XYIntervalSeries computeRegressionData(double xStart, double xEnd) {
    if (scatterpointsDataset.getItemCount(0) > 1) {
        final double[] coefficients = Regression.getOLSRegression(scatterpointsDataset, 0);
        final Function2D curve = new LineFunction2D(coefficients[0], coefficients[1]);
        final XYSeries regressionData = DatasetUtilities.sampleFunction2DToSeries(curve, xStart, xEnd, 100,
                "regression line");
        final XYIntervalSeries xyIntervalRegression = new XYIntervalSeries(regressionData.getKey());
        for (int i = 0; i < regressionData.getItemCount(); i++) {
            XYDataItem item = regressionData.getDataItem(i);
            final double x = item.getXValue();
            final double y = item.getYValue();
            xyIntervalRegression.add(x, x, x, y, y, y);
        }/*from  w  ww.  j  a  v  a  2  s  .c  om*/
        return xyIntervalRegression;
    } else {
        JOptionPane.showMessageDialog(this, "Unable to compute regression line.\n"
                + "At least 2 values are needed to compute regression coefficients.");
        return null;
    }
}

From source file:org.esa.beam.visat.toolviews.stat.ScatterPlotPanel.java

private XYIntervalSeries computeAcceptableDeviationData(double lowerBound, double upperBound) {
    final Function2D identityFunction = new Function2D() {
        @Override/*from   w w  w  .  jav  a2  s .c  om*/
        public double getValue(double x) {
            return x;
        }
    };

    final XYSeries identity = DatasetUtilities.sampleFunction2DToSeries(identityFunction, lowerBound,
            upperBound, 100, "1:1 line");
    final XYIntervalSeries xyIntervalSeries = new XYIntervalSeries(identity.getKey());
    final List<XYDataItem> items = identity.getItems();
    for (XYDataItem item : items) {
        final double x = item.getXValue();
        final double y = item.getYValue();
        if (scatterPlotModel.showAcceptableDeviation) {
            final double acceptableDeviation = scatterPlotModel.acceptableDeviationInterval;
            final double xOff = acceptableDeviation * x / 100;
            final double yOff = acceptableDeviation * y / 100;
            xyIntervalSeries.add(x, x - xOff, x + xOff, y, y - yOff, y + yOff);
        } else {
            xyIntervalSeries.add(x, x, x, y, y, y);
        }
    }
    return xyIntervalSeries;
}

From source file:org.esa.beam.visat.toolviews.stat.ScatterPlotPanel.java

private XYIntervalSeries computeRegressionData(double xStart, double xEnd) {
    if (scatterpointsDataset.getItemCount(0) > 1) {
        final double[] coefficients = Regression.getOLSRegression(scatterpointsDataset, 0);
        final Function2D curve = new LineFunction2D(coefficients[0], coefficients[1]);
        final XYSeries regressionData = DatasetUtilities.sampleFunction2DToSeries(curve, xStart, xEnd, 100,
                "regression line");
        final XYIntervalSeries xyIntervalRegression = new XYIntervalSeries(regressionData.getKey());
        final List<XYDataItem> regressionDataItems = regressionData.getItems();
        for (XYDataItem item : regressionDataItems) {
            final double x = item.getXValue();
            final double y = item.getYValue();
            xyIntervalRegression.add(x, x, x, y, y, y);
        }//from w  w  w . ja  v  a  2s  . co  m
        return xyIntervalRegression;
    } else {
        JOptionPane.showMessageDialog(this, "Unable to compute regression line.\n"
                + "At least 2 values are needed to compute regression coefficients.");
        return null;
    }
}

From source file:org.jfree.data.xy.XYSeries.java

/**
 * Updates the cached values for the minimum and maximum data values on
 * the basis that the specified item has just been removed.
 *
 * @param item  the item added (<code>null</code> not permitted).
 *
 * @since 1.0.13/*from   w w  w .  j ava2  s  .c  om*/
 */
private void updateBoundsForRemovedItem(XYDataItem item) {
    boolean itemContributesToXBounds = false;
    boolean itemContributesToYBounds = false;
    double x = item.getXValue();
    if (!Double.isNaN(x)) {
        if (x <= this.minX || x >= this.maxX) {
            itemContributesToXBounds = true;
        }
    }
    if (item.getY() != null) {
        double y = item.getYValue();
        if (!Double.isNaN(y)) {
            if (y <= this.minY || y >= this.maxY) {
                itemContributesToYBounds = true;
            }
        }
    }
    if (itemContributesToYBounds) {
        findBoundsByIteration();
    } else if (itemContributesToXBounds) {
        if (getAutoSort()) {
            this.minX = getX(0).doubleValue();
            this.maxX = getX(getItemCount() - 1).doubleValue();
        } else {
            findBoundsByIteration();
        }
    }
}

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

/***********************************************************************************************
 * Find the (nearest) XYDataItem index in the specified XYSeries, for the specified X position.
 *
 * @param xposition//from   ww  w  .j a  v  a 2  s  .  c o  m
 * @param xyseries
 *
 * @return int
 */

private static int findXYDataItemIndexForX(final double xposition, final XYSeries xyseries) {
    final String SOURCE = "ChartHelper.findXYDataItemIndexForX() ";
    int intIndex;

    intIndex = -1;

    // Let's be careful, in case something goes wrong...
    try {
        final List<XYDataItem> listDataItems;
        boolean boolFoundIt;

        listDataItems = xyseries.getItems();
        boolFoundIt = false;

        // Scan the whole Series to find the first Item with the correct X value
        for (int intItemIndex = 0; ((!boolFoundIt) && (intItemIndex < listDataItems.size())); intItemIndex++) {
            final XYDataItem dataItem;

            dataItem = listDataItems.get(intItemIndex);

            // The Domain Slider should be pointing at a real XYDataItem,
            // or at least very close to it...
            boolFoundIt = (dataItem.getXValue() >= xposition);

            if (boolFoundIt) {
                intIndex = intItemIndex;

                LOGGER.debug(LOADER_PROPERTIES.isChartDebug(),
                        SOURCE + "[item.index=" + intIndex + "] [series.size=" + listDataItems.size()
                                + "] [item.x=" + dataItem.getXValue() + "] [slider.x=" + xposition
                                + "] [found.it=" + boolFoundIt + "]");
            }
        }
    }

    catch (final IndexOutOfBoundsException exception) {
        LOGGER.error(SOURCE + "IndexOutOfBoundsException");
        intIndex = -1;
    }

    catch (final NullPointerException exception) {
        LOGGER.error(SOURCE + "NullPointerException");
        intIndex = -1;
    }

    return (intIndex);
}

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

/***********************************************************************************************
 * Dump the (partial) contents of each Series in an XYdatset.
 *
 * @param dump/*from  w  w  w. j ava 2s.  c  o  m*/
 * @param calendar
 * @param dataset
 * @param dumprowcount
 * @param title
 */

public static void dumpXYDataset(final boolean dump, final Calendar calendar, final XYDataset dataset,
        final int dumprowcount, final String title) {
    final String SOURCE = "ChartHelper.dumpXYDataset() ";

    if (dump) {
        LOGGER.log(title);

        if ((dataset != null) && (dataset instanceof XYSeriesCollection)) {
            final XYSeriesCollection seriesCollection;

            seriesCollection = (XYSeriesCollection) dataset;

            LOGGER.log("XYSeriesCollection");
            LOGGER.log("    [series.count=" + seriesCollection.getSeriesCount() + "]");
            LOGGER.log("    [domain.lowerbound.interval.true="
                    + (long) seriesCollection.getDomainLowerBound(true) + "]");
            LOGGER.log("    [domain.lowerbound.interval.false="
                    + (long) seriesCollection.getDomainLowerBound(false) + "]");
            LOGGER.log("    [domain.upperbound.interval.true="
                    + (long) seriesCollection.getDomainUpperBound(true) + "]");
            LOGGER.log("    [domain.upperbound.interval.false="
                    + (long) seriesCollection.getDomainUpperBound(false) + "]");
            LOGGER.log("    [domain.order=" + seriesCollection.getDomainOrder() + "]");

            for (int intSeriesIndex = 0; intSeriesIndex < seriesCollection.getSeriesCount(); intSeriesIndex++) {
                final XYSeries xySeries;

                LOGGER.log("");
                LOGGER.log("    [xyseries.index=" + intSeriesIndex + "]");

                xySeries = seriesCollection.getSeries(intSeriesIndex);
                LOGGER.log("    [xyseries.itemcount=" + xySeries.getItemCount() + "]");
                LOGGER.log("    [xyseries.key=" + xySeries.getKey() + "]");
                LOGGER.log("    [xyseries.xmin=" + xySeries.getMinX() + "]");
                LOGGER.log("    [xyseries.xmax=" + xySeries.getMaxX() + "]");
                LOGGER.log("    [xyseries.ymin=" + xySeries.getMinY() + "]");
                LOGGER.log("    [xyseries.ymax=" + xySeries.getMaxY() + "]");
                LOGGER.log("    [xyseries.description=" + xySeries.getDescription() + "]");
                LOGGER.log("    [xyseries.autosort=" + xySeries.getAutoSort() + "]");
                LOGGER.log("    [xyseries.allowduplicatex=" + xySeries.getAllowDuplicateXValues() + "]");

                // Dump the first chunk
                for (int intItemIndex = 0; intItemIndex < (Math.min(dumprowcount,
                        xySeries.getItemCount())); intItemIndex++) {
                    final XYDataItem item;

                    item = xySeries.getDataItem(intItemIndex);

                    LOGGER.log("        [item.index=" + intItemIndex + "] [item.x=" + item.getXValue()
                            + "] [item.y=" + item.getYValue() + "]");
                }

                LOGGER.log("    ...");

                // Dump the last chunk
                for (int intItemIndex = 0; intItemIndex < (Math.min(dumprowcount,
                        xySeries.getItemCount())); intItemIndex++) {
                    final XYDataItem item;
                    final int intIndex;

                    intIndex = Math.max(0, xySeries.getItemCount() - dumprowcount) + intItemIndex;
                    item = xySeries.getDataItem(intIndex);

                    LOGGER.log("        [item.index=" + intIndex + "] [item.x=" + item.getXValue()
                            + "] [item.y=" + item.getYValue() + "]");
                }
            }
        } else if ((dataset != null) && (dataset instanceof TimeSeriesCollection)) {
            final TimeSeriesCollection seriesCollection;

            seriesCollection = (TimeSeriesCollection) dataset;

            LOGGER.log("TimeSeriesCollection");
            LOGGER.log("    [series.count=" + seriesCollection.getSeriesCount() + "]");
            LOGGER.log("    [domain.lowerbound.interval.true="
                    + (long) seriesCollection.getDomainLowerBound(true) + "]");
            LOGGER.log("    [domain.lowerbound.interval.false="
                    + (long) seriesCollection.getDomainLowerBound(false) + "]");
            LOGGER.log("    [domain.upperbound.interval.true="
                    + (long) seriesCollection.getDomainUpperBound(true) + "]");
            LOGGER.log("    [domain.upperbound.interval.false="
                    + (long) seriesCollection.getDomainUpperBound(false) + "]");
            LOGGER.log("    [domain.order=" + seriesCollection.getDomainOrder() + "]");

            for (int intSeriesIndex = 0; intSeriesIndex < seriesCollection.getSeriesCount(); intSeriesIndex++) {
                final TimeSeries timeSeries;

                LOGGER.log("");
                LOGGER.log("    [timeseries.index=" + intSeriesIndex + "]");

                timeSeries = seriesCollection.getSeries(intSeriesIndex);
                LOGGER.log("    [timeseries.itemcount=" + timeSeries.getItemCount() + "]");
                LOGGER.log("    [timeseries.key=" + timeSeries.getKey() + "]");
                LOGGER.log("    [timeseries.ymin=" + timeSeries.getMinY() + "]");
                LOGGER.log("    [timeseries.ymax=" + timeSeries.getMaxY() + "]");
                LOGGER.log("    [timeseries.domain=" + timeSeries.getDomainDescription() + "]");
                LOGGER.log("    [timeseries.range=" + timeSeries.getRangeDescription() + "]");
                LOGGER.log(
                        "    [timeseries.timeperiodclass=" + timeSeries.getTimePeriodClass().getName() + "]");

                for (int intItemIndex = 0; intItemIndex < (Math.min(dumprowcount,
                        timeSeries.getItemCount())); intItemIndex++) {
                    final TimeSeriesDataItem item;

                    item = timeSeries.getDataItem(intItemIndex);

                    LOGGER.log("        [item.index=" + intItemIndex + "] [item.period.serialindex="
                            + item.getPeriod().getSerialIndex() + "] [item.period.firstmillis="
                            + item.getPeriod().getFirstMillisecond(calendar) + "] [item.value="
                            + item.getValue() + "]");
                }

                LOGGER.log("    ...");

                for (int intItemIndex = 0; intItemIndex < (Math.min(dumprowcount,
                        timeSeries.getItemCount())); intItemIndex++) {
                    final TimeSeriesDataItem item;
                    final int intIndex;

                    intIndex = Math.max(0, timeSeries.getItemCount() - dumprowcount) + intItemIndex;
                    item = timeSeries.getDataItem(intIndex);

                    LOGGER.log("        [item.index=" + intIndex + "] [item.period.serialindex="
                            + item.getPeriod().getSerialIndex() + "] [item.period.firstmillis="
                            + item.getPeriod().getFirstMillisecond(calendar) + "] [item.value="
                            + item.getValue() + "]");
                }
            }
        } else {
            LOGGER.error(SOURCE + "Unsupported XYDataset type");
        }
    }
}

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/*from  w  ww .  jav  a  2  s.  c  om*/
 *        |
 *        |  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);
}