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:com.bwc.ora.models.Lrp.java

private static double calculateXFromYForLineWithTwoPoints(XYDataItem pt1, XYDataItem pt2, double y) {
    //        System.out.println("    P1: (" + pt1.getXValue() + "," + pt1.getYValue() + ")");
    //        System.out.println("    P2: (" + pt2.getXValue() + "," + pt2.getYValue() + ")");
    //calculate slope 
    double slope = (pt1.getYValue() - pt2.getYValue()) / (pt1.getXValue() - pt2.getXValue());
    //        System.out.println("    Slope: " + slope);
    //calculate y value at y-intercept (aka b)
    double yint = pt1.getYValue() - (slope * pt1.getXValue());
    //        System.out.println("    Y-int: " + yint);
    //return /*w w w .j  av  a 2 s  . c om*/
    return (y - yint) / slope;
}

From source file:com.jbombardier.console.charts.XYTimeChartPanel.java

private Double findValue(XYSeries xySeries, long xValue) {
    Double value = null;/*from ww  w  . jav a  2s .  c  o m*/

    List<XYDataItem> items = xySeries.getItems();
    for (XYDataItem item : items) {
        double itemXValue = item.getXValue();
        long xTimeValue = (long) itemXValue;

        if (xTimeValue == xValue) {
            value = item.getYValue();
            break;
        }
    }

    return value;
}

From source file:org.usfirst.frc.team2084.neuralnetwork.HeadingNeuralNetworkTrainer.java

private void trainNetwork() {
    if (!training) {

        // Set training flag and disable button
        training = true;/*from   w  w  w. ja  v a 2s.c  o  m*/
        trainButton.setEnabled(false);

        final ProgressMonitor progressMonitor = new ProgressMonitor(frame, "Training Network...", "", 0, 100);
        progressMonitor.setMillisToDecideToPopup(100);
        progressMonitor.setMillisToPopup(400);

        @SuppressWarnings("unchecked")
        final ArrayList<XYDataItem> data = new ArrayList<>(outputGraphDataSeries.getItems());

        final int maxProgress = iterations * data.size();

        final SwingWorker<Void, Void> trainingWorker = new SwingWorker<Void, Void>() {

            @Override
            protected Void doInBackground() throws Exception {
                // Reset the neural network to default values
                synchronized (this) {
                    network.reset();
                    network.setEta(eta);
                    network.setMomentum(momentum);
                }

                outer: for (int j = 0; j < iterations; j++) {
                    for (int i = 0; i < data.size(); i++) {
                        if (!isCancelled()) {
                            XYDataItem d = data.get(i);
                            double error = convertAngleToInput(d.getXValue());
                            double output = d.getYValue();
                            synchronized (this) {
                                network.feedForward(error);
                                network.backPropagation(output);
                            }
                            int jl = j;
                            int il = i;
                            int progress = (int) (((float) (data.size() * jl + il + 1) / maxProgress) * 100);
                            setProgress(progress);
                        } else {
                            break outer;
                        }
                    }
                }

                displayNetwork();
                return null;
            }

            @Override
            protected void done() {
                training = false;
                trainButton.setEnabled(true);
                progressMonitor.close();
            }
        };
        trainingWorker.addPropertyChangeListener(new PropertyChangeListener() {

            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                if (evt.getPropertyName().equals("progress")) {
                    progressMonitor.setProgress((int) evt.getNewValue());
                }
                if (progressMonitor.isCanceled()) {
                    trainingWorker.cancel(true);
                }
            }
        });
        trainingWorker.execute();
    }
}

From source file:com.jbombardier.console.charts.XYTimeChartPanel.java

public void saveChartData() {
    StringBuilder builder = new StringBuilder();
    synchronized (seriesForSource) {
        Set<Long> xValues = new HashSet<Long>();

        Collection<XYSeries> values = seriesForSource.values();
        for (XYSeries xySeries : values) {
            List<XYDataItem> items = xySeries.getItems();
            for (XYDataItem item : items) {
                double xValue = item.getXValue();
                long xTimeValue = (long) xValue;
                xValues.add(xTimeValue);
            }/*w w w .  j  a  v  a 2  s  . c  om*/
        }

        List<Long> xValuesList = new ArrayList<Long>(xValues);
        Collections.sort(xValuesList);
        Set<String> keys = seriesForSource.keySet();

        builder.append("Time,");
        for (String seriesKey : keys) {
            builder.append(seriesKey).append(",");
        }
        builder.append(newline);

        for (Long xValue : xValuesList) {
            Date date = new Date(xValue);
            builder.append(date.toString());
            builder.append(",");
            for (String seriesKeys : keys) {
                XYSeries xySeries = seriesForSource.get(seriesKeys);
                Double d = findValue(xySeries, xValue);
                if (d != null) {
                    builder.append(d);
                }
                builder.append(",");
            }

            builder.append(newline);
        }
    }

    String filename = chart.getTitle().getText() + ".csv";
    File file = new File(filename);
    FileUtils.write(builder.toString(), file);
    Out.out("Data saved to '{}'", file.getAbsolutePath());
}

From source file:edu.fullerton.viewerplugin.TsPlot.java

private XYSeries LinFit(XYSeries ts) {
    XYSeries ret = new XYSeries("lin fit", false);

    int n = ts.getItemCount();
    double[] x = new double[n];
    double[] y = new double[n];
    XYDataItem it;
    for (int i = 0; i < n; i++) {
        it = ts.getDataItem(i);//from  w  ww  .  j  a v  a  2  s .  co m
        x[i] = it.getXValue();
        y[i] = it.getYValue();
    }
    LinearRegression lr = new LinearRegression(x, y);
    double b = lr.getIntercept();
    double m = lr.getSlope();
    double fit, t;
    for (int i = 0; i < n; i++) {

        it = ts.getDataItem(i);
        t = it.getXValue();
        fit = m * t + b;

        ret.add(t, fit);
    }

    return ret;
}

From source file:com.bwc.ora.models.Lrp.java

public List<XYSeries> getFWHMForLRPPeaks(XYSeries lrpPeaks, XYSeries lrpSeries) {
    LinkedList<XYSeries> seriesList = new LinkedList<>();
    List<XYDataItem> pointList = (List<XYDataItem>) lrpSeries.getItems();
    List<XYDataItem> peakList = (List<XYDataItem>) lrpPeaks.getItems();
    //iterate through the peaks, process FWHM for each peak
    for (XYDataItem peak : peakList) {
        //grab index of the closest point to the peak
        int peakIndex = -1;
        for (XYDataItem pnt : pointList) {
            peakIndex++;/*from   w  ww.  jav  a  2s. co  m*/
            if (Math.abs(pnt.getXValue() - peak.getXValue()) < 0.6D) {
                break;
            }
        }
        //calculate point with Y value of valley to the left of peak
        XYDataItem leftValleyPoint = null;
        ListIterator<XYDataItem> it = pointList.listIterator(peakIndex);
        double prevY = peak.getYValue();
        while (it.hasPrevious()) {
            XYDataItem leftPoint = it.previous();
            if (leftPoint.getYValue() <= prevY) {
                prevY = leftPoint.getYValue();
                leftValleyPoint = leftPoint;
            } else {
                break;
            }
        }
        //calculate point with Y value of valley to the right of peak
        XYDataItem rightValleyPoint = null;
        it = pointList.listIterator(peakIndex);
        prevY = peak.getYValue();
        while (it.hasNext()) {
            XYDataItem rightPoint = it.next();
            if (rightPoint.getYValue() <= prevY) {
                prevY = rightPoint.getYValue();
                rightValleyPoint = rightPoint;
            } else {
                break;
            }
        }
        //determine half max Y value
        double halfMaxYValue;
        if (rightValleyPoint.getYValue() == leftValleyPoint.getYValue()) {
            halfMaxYValue = peak.getYValue() - ((peak.getYValue() - leftValleyPoint.getYValue()) / 2D);
        } else if (rightValleyPoint.getYValue() > leftValleyPoint.getYValue()) {
            halfMaxYValue = peak.getYValue() - ((peak.getYValue() - rightValleyPoint.getYValue()) / 2D);
        } else {
            halfMaxYValue = peak.getYValue() - ((peak.getYValue() - leftValleyPoint.getYValue()) / 2D);
        }
        //determine the X value on both sides of the peak that corresponds to the half max Y value
        double leftX = pointList.get(0).getXValue(), rightX = pointList.get(pointList.size() - 1).getXValue();
        XYDataItem prevPoint = pointList.get(peakIndex);
        it = pointList.listIterator(peakIndex);
        while (it.hasPrevious()) {
            XYDataItem leftPoint = it.previous();
            if (leftPoint.getYValue() == halfMaxYValue) {
                leftX = leftPoint.getXValue();
                break;
            } else {
                if (leftPoint.getYValue() < halfMaxYValue) {
                    //                        System.out.println("Left X for peak (" + peak.getXValue() + "," + peak.getYValue() + "): ");
                    leftX = calculateXFromYForLineWithTwoPoints(leftPoint, prevPoint, halfMaxYValue);
                    //                        System.out.println("    Left X: (" + leftX + "," + halfMaxYValue + "): ");
                    break;
                } else {
                    prevPoint = leftPoint;
                }
            }
        }
        prevPoint = pointList.get(peakIndex);
        it = pointList.listIterator(peakIndex);
        while (it.hasNext()) {
            XYDataItem rightPoint = it.next();
            if (rightPoint.getYValue() == halfMaxYValue) {
                rightX = rightPoint.getXValue();
                break;
            } else {
                if (rightPoint.getYValue() < halfMaxYValue) {
                    //                        System.out.println("Right X for peak (" + peak.getXValue() + "," + peak.getYValue() + "): ");
                    rightX = calculateXFromYForLineWithTwoPoints(rightPoint, prevPoint, halfMaxYValue);
                    //                        System.out.println("    Right X: (" + leftX + "," + halfMaxYValue + "): ");
                    break;
                } else {
                    prevPoint = rightPoint;
                }
            }
        }
        //store the two points for the half max full width line for this peak
        XYSeries peakSeries = new XYSeries("(" + peak.getXValue() + "," + peak.getYValue() + ")FWHM");
        peakSeries.add(leftX, halfMaxYValue);
        peakSeries.add(rightX, halfMaxYValue);
        seriesList.add(peakSeries);
    }
    return seriesList;
}

From source file:com.bwc.ora.models.Lrp.java

public static XYSeries findMaximums(XYSeries lrpSeries, String title) {
    XYSeries lrpMaxPoints = new XYSeries(title);
    XYDataItem leftPeakPoint = new XYDataItem(0, 0);
    int leftPeakPointIndex = 0;
    XYDataItem rightPeakPoint = new XYDataItem(0, 0);
    boolean first = true;
    int index = -1;
    List<XYDataItem> pointList = (List<XYDataItem>) lrpSeries.getItems();
    for (XYDataItem point : pointList) {
        index++;//from   w ww.ja v  a2s  .c o  m
        if (first) {
            leftPeakPoint = point;
            leftPeakPointIndex = index;
            first = false;
            continue;
        }
        if (leftPeakPoint.getYValue() < point.getYValue()) {
            leftPeakPoint = point;
            leftPeakPointIndex = index;
            rightPeakPoint = point;
        } else if (leftPeakPoint.getYValue() == point.getYValue()) {
            rightPeakPoint = point;
        } else {
            //determine if we are coming down off of a peak by looking two points behind the current point
            if (leftPeakPointIndex > 0) {
                XYDataItem prev = pointList.get(leftPeakPointIndex - 1);
                //if two points back has a Y value that is less than or equal to the left peak point
                //then we have found the end of the peak and we can process as such
                if (prev.getYValue() <= leftPeakPoint.getYValue()) {
                    double peakx = rightPeakPoint.getXValue()
                            - ((rightPeakPoint.getXValue() - leftPeakPoint.getXValue()) / 2D);
                    lrpMaxPoints.add(peakx, leftPeakPoint.getY());
                }
            }
            leftPeakPoint = point;
            leftPeakPointIndex = index;
            rightPeakPoint = point;
        }
    }

    return lrpMaxPoints;
}

From source file:com.ivli.roim.controls.ChartControl.java

@Override
public void actionPerformed(ActionEvent e) {
    super.actionPerformed(e);
    final XYPlot plot = getChart().getXYPlot();

    switch (MENUS.translate(e.getActionCommand())) {
    case ADD:/*  w  ww.  j  a v a  2s.c om*/
        if (null != iSeries && iSeries instanceof XYSeries) {
            addMarker(new DomainMarker(iDataItem.getXValue(), iSeries));
        }
        break;
    case EXPORT_CSV:
        if (null != iSeries && iSeries instanceof XYSeries) {
            FileOpenDialog dlg = new FileOpenDialog(
                    java.util.ResourceBundle.getBundle("com/ivli/roim/Bundle").getString("CHOICE_FILE_TO_OPEN"),
                    "csv", //NOI18N 
                    "CSV file", //NOI18N 
                    false);

            if (dlg.doModal()) {
                try (Writer pwr = new PrintWriter(dlg.getFileName())) { //NOI18N                              
                    for (int i = 0; i < iSeries.getItemCount(); ++i) {
                        XYDataItem xy = iSeries.getDataItem(i);
                        pwr.append(String.format("%f\t%f\n", xy.getXValue(), xy.getYValue())); //NOI18N                        
                    }
                    pwr.flush();
                    pwr.close();
                } catch (IOException ex) {
                    LOG.throwing(ex);
                }
            }
        }
        break;
    case MOVE_TO_MAX:
        iMarker.setValue(XYSeriesUtilities.getDomainValueOfMaximum(((DomainMarker) iMarker).getSeries()));
        break;//((DomainMarker)iMarker).moveToMaximum(DomainMarker.MOVETO.GLOBAL)); break;                           
    case MOVE_TO_MIN:
        iMarker.setValue(XYSeriesUtilities.getDomainValueOfMinimum(((DomainMarker) iMarker).getSeries()));
        break;
    case MOVE_TO_MEDIAN: {
        iMarker.setValue(XYSeriesUtilities.getDomainValueOfMaximum(((DomainMarker) iMarker).getSeries()));
        double medY = (iSeries.getMaxY() - iSeries.getMinY()) / 2.;
        double val = XYSeriesUtilities.getNearestX(iSeries, medY);

        if (Double.isFinite(val))
            iMarker.setValue(val);
    }
        ;
        break;
    case DELETE:
        removeMarker((DomainMarker) iMarker);
        break;
    case DELETE_ALL:
        plot.getDomainMarkers(Layer.FOREGROUND).clear();
        iInterpolations.stream().forEach((i) -> {
            i.close();
        });
        iInterpolations.clear();
        break;
    case FIT_LEFT:
    case FIT_RIGHT: {
        final FITDIR dir = (MENUS.FIT_LEFT == MENUS.translate(e.getActionCommand()) ? FITDIR.FIT_LEFT
                : FITDIR.FIT_RIGHT);

        List<DomainMarker> list = (new ArrayList<DomainMarker>(plot.getDomainMarkers(Layer.FOREGROUND)))
                .stream().filter((DomainMarker m) -> {
                    return ((DomainMarker) iMarker).getSeries() == m.getSeries();
                }).sorted((DomainMarker aLhs, DomainMarker aRhs) -> {
                    return (int) (aLhs.getValue() - aRhs.getValue());
                }).collect(Collectors.toList());

        LOG.debug("-->Found " + list.size() + " markers");

        switch (list.size()) {
        case 0:
            break;
        case 1:
            iInterpolations.add(new Interpolation((DomainMarker) iMarker, dir));
            break;
        case 2: //fallthrough as default
        default: {
            DomainMarker left = null, right = null;
            int ndx = list.indexOf(iMarker);
            if (dir == FITDIR.FIT_LEFT) {
                if (ndx >= 1) {
                    right = (DomainMarker) iMarker;
                    left = list.get(--ndx);
                    iInterpolations.add(new Interpolation(left, right));
                } else {
                    iInterpolations.add(new Interpolation((DomainMarker) iMarker, dir));
                }

            } else if (dir == FITDIR.FIT_RIGHT) {
                if (ndx < list.size() - 1) {
                    right = list.get(++ndx);
                    left = (DomainMarker) iMarker;
                    iInterpolations.add(new Interpolation(left, right));
                } else {
                    iInterpolations.add(new Interpolation((DomainMarker) iMarker, dir));
                }
            }
        }
            break;
        }
    }
        break;
    default:
        break;
    }

    dropSelection();
}

From source file:oct.analysis.application.OCTSelection.java

private double calculateXFromYForLineWithTwoPoints(XYDataItem pt1, XYDataItem pt2, double y) {
    //        System.out.println("    P1: (" + pt1.getXValue() + "," + pt1.getYValue() + ")");
    //        System.out.println("    P2: (" + pt2.getXValue() + "," + pt2.getYValue() + ")");
    //calculate slope 
    double slope = (pt1.getYValue() - pt2.getYValue()) / (pt1.getXValue() - pt2.getXValue());
    //        System.out.println("    Slope: " + slope);
    //calculate y value at y-intercept (aka b)
    double yint = pt1.getYValue() - (slope * pt1.getXValue());
    //        System.out.println("    Y-int: " + yint);
    //return /*w  w  w . j a v  a2s .  co  m*/
    return (y - yint) / slope;
}

From source file:be.vds.jtbdive.client.view.core.dive.profile.DiveProfileGraphicDetailPanel.java

public DiveProfile getDisplayedProfile() {
    DiveProfile dp = new DiveProfile();

    Map<Double, Double> depthMap = new HashMap<Double, Double>();
    for (int i = 0; i < depthSerie.getItemCount(); i++) {
        XYDataItem data = depthSerie.getDataItem(i);
        depthMap.put(data.getXValue(), data.getYValue());
    }/*from  w w w  .jav  a2  s.  c o  m*/

    if (depthMap.size() > 0) {
        dp.setDepthEntries(depthMap);

        // Ascent warning
        Set<Double> ascentWarning = new HashSet<Double>();
        for (int i = 0; i < ascentTooFastSerie.getItemCount(); i++) {
            XYDataItem data = ascentTooFastSerie.getDataItem(i);
            ascentWarning.add(data.getXValue());
        }
        if (ascentWarning.size() > 0) {
            dp.setAscentWarnings(ascentWarning);
        }

        // Deco warning
        Set<Double> decoWarningSet = new HashSet<Double>();
        for (int i = 0; i < decoWarningSerie.getItemCount(); i++) {
            XYDataItem data = decoWarningSerie.getDataItem(i);
            decoWarningSet.add(data.getXValue());
        }
        if (decoWarningSet.size() > 0) {
            dp.setDecoCeilingWarnings(decoWarningSet);
        }

        // Remain bottom time
        Set<Double> remainBottomTimeSet = new HashSet<Double>();
        for (int i = 0; i < remainBottomTimeSerie.getItemCount(); i++) {
            XYDataItem data = remainBottomTimeSerie.getDataItem(i);
            remainBottomTimeSet.add(data.getXValue());
        }
        if (remainBottomTimeSet.size() > 0) {
            dp.setRemainingBottomTimeWarnings(remainBottomTimeSet);
        }

        // DecoEntries
        Set<Double> decoEntriesSet = new HashSet<Double>();
        for (int i = 0; i < decoEntriesSerie.getItemCount(); i++) {
            XYDataItem data = decoEntriesSerie.getDataItem(i);
            decoEntriesSet.add(data.getXValue());
        }
        if (decoEntriesSet.size() > 0) {
            dp.setDecoEntries(decoEntriesSet);
        }

        return dp;
    }

    return null;
}