private static XYDatasetMinMax createDeltaDataset( String name, SortedMap<TimeAxisKey, DiffStat> aggregatedDiffstats) { TimeSeriesCollection dataset = new TimeSeriesCollection(); int minimum = 0; int maximum = 0; TimeSeries addedSeries = new TimeSeries(name); TimeSeries removedSeries = new TimeSeries(name); for (Entry<TimeAxisKey, DiffStat> entry : aggregatedDiffstats.entrySet()) { TimeAxisKey timeAxisKey = entry.getKey(); DiffStat diffStat = entry.getValue(); RegularTimePeriod period = timeAxisKey.toPeriod(); int added = diffStat.added(); maximum = max(maximum, added); addedSeries.add(period, Integer.valueOf(added)); int removed = -diffStat.removed(); minimum = min(minimum, removed); removedSeries.add(period, Integer.valueOf(removed)); } dataset.addSeries(addedSeries); dataset.addSeries(removedSeries); return new XYDatasetMinMax(dataset, minimum, maximum); }
public Chart(String filename) { try { // Get Stock Symbol this.stockSymbol = filename.substring(0, filename.indexOf('.')); // Create time series TimeSeries open = new TimeSeries("Open Price", Day.class); TimeSeries close = new TimeSeries("Close Price", Day.class); TimeSeries high = new TimeSeries("High", Day.class); TimeSeries low = new TimeSeries("Low", Day.class); TimeSeries volume = new TimeSeries("Volume", Day.class); BufferedReader br = new BufferedReader(new FileReader(filename)); String key = br.readLine(); String line = br.readLine(); while (line != null && !line.startsWith("<!--")) { StringTokenizer st = new StringTokenizer(line, ",", false); Day day = getDay(st.nextToken()); double openValue = Double.parseDouble(st.nextToken()); double highValue = Double.parseDouble(st.nextToken()); double lowValue = Double.parseDouble(st.nextToken()); double closeValue = Double.parseDouble(st.nextToken()); long volumeValue = Long.parseLong(st.nextToken()); // Add this value to our series' open.add(day, openValue); close.add(day, closeValue); high.add(day, highValue); low.add(day, lowValue); // Read the next day line = br.readLine(); } // Build the datasets dataset.addSeries(open); dataset.addSeries(close); dataset.addSeries(low); dataset.addSeries(high); datasetOpenClose.addSeries(open); datasetOpenClose.addSeries(close); datasetHighLow.addSeries(high); datasetHighLow.addSeries(low); JFreeChart summaryChart = buildChart(dataset, "Summary", true); JFreeChart openCloseChart = buildChart(datasetOpenClose, "Open/Close Data", false); JFreeChart highLowChart = buildChart(datasetHighLow, "High/Low Data", true); JFreeChart highLowDifChart = buildDifferenceChart(datasetHighLow, "High/Low Difference Chart"); // Create this panel this.setLayout(new GridLayout(2, 2)); this.add(new ChartPanel(summaryChart)); this.add(new ChartPanel(openCloseChart)); this.add(new ChartPanel(highLowChart)); this.add(new ChartPanel(highLowDifChart)); } catch (Exception e) { e.printStackTrace(); } }
/** * Creates a dataset, consisting of two series of monthly data. * * @return The dataset. * @throws Exception */ private static XYDataset createDataset(int id) throws Exception { TimeSeries s2 = new TimeSeries("Linea Uscite"); TimeSeries s1 = new TimeSeries("Linea Entrate"); boolean controllo = true; ArrayList<entrate> datiEntrate = EntrateDAO.getEntrate(id); ArrayList<uscite> datiUscite = UsciteDAO.getUscite(id); for (entrate e : datiEntrate) { s1.add( new Day(e.getData().getDate(), e.getData().getMonth() + 1, e.getData().getYear() + 1900), e.getQuantita()); } for (uscite e : datiUscite) { s2.add( new Day(e.getData().getDate(), e.getData().getMonth() + 1, e.getData().getYear() + 1900), e.getQuantita()); } TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(s1); dataset.addSeries(s2); return dataset; }
private TimeSeriesCollection createTotalDataset() { List<BigDecimal> values = intervalReport.getValues(); DateIterator dateIterator = intervalReport.dateIterator(); List<BigDecimal> inventoryValues = intervalReport.getInventoryValues(); List<BigDecimal> investmentValues = intervalReport.getInvestmentValues(); TimeSeries s1 = new TimeSeries(getEditorInput().getName(), Day.class); TimeSeries s2 = new TimeSeries("Invested sum", Day.class); BigDecimal sum = BigDecimal.ZERO; Iterator<BigDecimal> iterator1 = inventoryValues.iterator(); Iterator<BigDecimal> iterator2 = investmentValues.iterator(); for (BigDecimal v : values) { sum = sum.add(v); de.tomsplayground.util.Day d = dateIterator.next(); Day day = new Day(d.day, d.month + 1, d.year); BigDecimal v1 = sum.add(iterator1.next()); s1.add(day, v1); BigDecimal v2 = iterator2.next(); s2.add(day, v2); } TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(s1); dataset.addSeries(s2); return dataset; }
/** * @param forecast * @param settings (next days) * @return */ public JFreeChart createBarChart( final LiquidityForecast forecast, final LiquidityForecastSettings settings) { Validate.isTrue(settings.getNextDays() > 0 && settings.getNextDays() < 500); final LiquidityForecastCashFlow cashFlow = new LiquidityForecastCashFlow(forecast, settings.getNextDays()); final TimeSeries accumulatedSeriesExpected = new TimeSeries(I18n.getString("plugins.liquidityplanning.forecast.expected")); final TimeSeries creditSeries = new TimeSeries(I18n.getString("plugins.liquidityplanning.common.credit")); final TimeSeries debitSeries = new TimeSeries(I18n.getString("plugins.liquidityplanning.common.debit")); double accumulatedExpected = settings.getStartAmount().doubleValue(); final DayHolder dh = new DayHolder(); final Date lower = dh.getDate(); for (int i = 0; i < settings.getNextDays(); i++) { final Day day = new Day(dh.getDayOfMonth(), dh.getMonth() + 1, dh.getYear()); if (i > 0) { accumulatedExpected += cashFlow.getDebitsExpected()[i - 1].doubleValue() + cashFlow.getCreditsExpected()[i - 1].doubleValue(); } accumulatedSeriesExpected.add(day, accumulatedExpected); creditSeries.add(day, cashFlow.getCreditsExpected()[i].doubleValue()); debitSeries.add(day, cashFlow.getDebitsExpected()[i].doubleValue()); dh.add(Calendar.DATE, 1); } dh.add(Calendar.DATE, -1); final XYChartBuilder cb = new XYChartBuilder( ChartFactory.createXYBarChart( null, null, false, null, null, PlotOrientation.VERTICAL, false, false, false)); int counter = 0; final TimeSeriesCollection xyDataSeries = new TimeSeriesCollection(); xyDataSeries.addSeries(accumulatedSeriesExpected); final XYLineAndShapeRenderer lineRenderer = new XYLineAndShapeRenderer(true, true); lineRenderer.setSeriesPaint(0, cb.getRedMarker()); lineRenderer.setSeriesVisibleInLegend(0, true); cb.setRenderer(counter, lineRenderer) .setDataset(counter++, xyDataSeries) .setStrongStyle(lineRenderer, false, accumulatedSeriesExpected); final TimeSeriesCollection cashflowSet = new TimeSeriesCollection(); cashflowSet.addSeries(debitSeries); cashflowSet.addSeries(creditSeries); final XYBarRenderer barRenderer = new XYBarRenderer(.2); barRenderer.setSeriesPaint(0, cb.getGreenFill()); barRenderer.setSeriesPaint(1, cb.getRedFill()); barRenderer.setShadowVisible(false); cb.setRenderer(counter, barRenderer).setDataset(counter++, cashflowSet); cb.setDateXAxis(true).setDateXAxisRange(lower, dh.getDate()).setYAxis(true, null); return cb.getChart(); }
private void setDataByRow(final IPentahoResultSet data) { // TODO Make this routine MDX friendly if (data == null) { noDataMessage = Messages.getInstance().getString("CHART.USER_NO_DATA_AVAILABLE"); // $NON-NLS-1$ return; // No data so we've got nothing to set // TODO come up with some sort of error strategy here. } Class timePeriodClass = TimeSeriesCollectionChartDefinition.getTimePeriodClass(getDomainPeriodType()); Object[] rowData = data.next(); while (rowData != null) { String seriesName = (String) rowData[0]; TimeSeries wrkSeries = new TimeSeries(seriesName, timePeriodClass); for (int column = 1; column < rowData.length - 1; column = column + 2) { Date keyDate = getValidDate(rowData[column]); TimeSeriesDataItem timeSeriesDataItem = new TimeSeriesDataItem( RegularTimePeriod.createInstance( timePeriodClass, keyDate, RegularTimePeriod.DEFAULT_TIME_ZONE), ((Number) rowData[column + 1]).doubleValue()); wrkSeries.add(timeSeriesDataItem); } addSeries(wrkSeries); rowData = data.next(); } if ((data.getRowCount() > 0) && (this.getSeriesCount() <= 0)) { noDataMessage = Messages.getInstance().getString("CHART.USER_INCORRECT_DATA_FORMAT"); // $NON-NLS-1$ } }
public static void addMillisecond(TimeSeries timeSeries, long time, Number value) { try { timeSeries.add(new Millisecond(new Date(time)), value); } catch (SeriesException e) { /* duplicate Second. Ignore. */ } }
private IntervalXYDataset startDataSet(TimeSeriesDataItem[] dataAsArray) { timeSeries = new TimeSeries(BAR_LABEL, X_LABEL, "Count"); for (TimeSeriesDataItem dataItem : dataAsArray) { timeSeries.add(dataItem); } TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(timeSeries); return timeseriescollection; }
/** * Builds a JFreeChart time series from a Ta4j time series and an indicator. * * @param tickSeries the ta4j time series * @param indicator the indicator * @param name the name of the chart time series * @return the JFreeChart time series */ private static org.jfree.data.time.TimeSeries buildChartTimeSeries( TimeSeries tickSeries, Indicator<Decimal> indicator, String name) { org.jfree.data.time.TimeSeries chartTimeSeries = new org.jfree.data.time.TimeSeries(name); for (int i = 0; i < tickSeries.getTickCount(); i++) { Tick tick = tickSeries.getTick(i); chartTimeSeries.add(new Day(tick.getEndTime().toDate()), indicator.getValue(i).toDouble()); } return chartTimeSeries; }
public void actionPerformed(ActionEvent actionevent) { if (actionevent.getActionCommand().equals("ADD_DATA")) { double d = 0.90000000000000002D + 0.20000000000000001D * Math.random(); lastValue = lastValue * d; Millisecond millisecond = new Millisecond(); System.out.println("Now = " + millisecond.toString()); series.add(new Millisecond(), lastValue); } }
@Override public void update(Observable arg0, Object arg1) { // TODO Auto-generated method stub if (arg0 instanceof Context) { Context tep = (Context) arg0; timeSeries.add(new Millisecond(), tep.get(), true); jfreechart.fireChartChanged(); } }
public void run() { while (true) { try { System.out.println(context.get()); timeSeries.add(new Millisecond(), context.get(), true); Thread.sleep(300); } catch (InterruptedException e) { } } }
protected TimeSeries getScopingTimeSeries( List<IterationHistoryEntry> iterationHistoryEntries, LocalDate startDate, LocalDate endDate) { TimeSeries scopingSeries = new TimeSeries(SCOPING_SERIES_NAME); for (LocalDate iter = startDate.minusDays(1); iter.compareTo(endDate.plusDays(1)) < 0; iter = iter.plusDays(1)) { IterationHistoryEntry todayEntry = getHistoryEntryForDate(iterationHistoryEntries, iter); IterationHistoryEntry yesterdayEntry = getHistoryEntryForDate(iterationHistoryEntries, iter.minusDays(1)); if (isScopingDone(todayEntry)) { List<TimeSeriesDataItem> scopeItems = getScopeSeriesDataItems(yesterdayEntry, todayEntry); scopingSeries.add(scopeItems.get(0)); scopingSeries.add(scopeItems.get(1)); scopingSeries.add(scopeItems.get(2)); } } return scopingSeries; }
protected TimeSeries getReferenceVelocityWithWeekends( String seriesKey, DateTime startDate, DateTime endDate, ExactEstimate oeSum) { TimeSeries ts = new TimeSeries(seriesKey); MutableDateTime date; startDate = startDate.minusMinutes(timeDifferenceMinutes).toDateMidnight().toDateTime(); endDate = endDate.minusMinutes(timeDifferenceMinutes).toDateMidnight().toDateTime(); double originalEstimate = ExactEstimateUtils.extractMajorUnits(oeSum); ts.add(new TimeSeriesDataItem(new Second(startDate.toDate()), originalEstimate)); // Get the amount of work days int amountOfWorkDays = 0; for (date = new MutableDateTime(startDate); date.isBefore(endDate.plusDays(1)); date.addDays(1)) { if (date.dayOfWeek().get() != DateTimeConstants.SATURDAY && date.dayOfWeek().get() != DateTimeConstants.SUNDAY) { amountOfWorkDays++; } } double decrement = originalEstimate / ((double) amountOfWorkDays); double currentval = ExactEstimateUtils.extractMajorUnits(oeSum); for (date = new MutableDateTime(startDate); date.isBefore(endDate); date.addDays(1)) { if (date.dayOfWeek().get() != DateTimeConstants.SATURDAY && date.dayOfWeek().get() != DateTimeConstants.SUNDAY) { currentval -= decrement; } ts.add( new TimeSeriesDataItem(new Second(date.toDateTime().plusDays(1).toDate()), currentval)); } ts.add(new TimeSeriesDataItem(new Second(endDate.plusDays(1).toDate()), 0.0)); return ts; }
/** * Creates the demo chart. * * @return The chart. * <p>private JFreeChart createChart() { * <p>XYDataset dataset1 = createDataset("Series 1", 100.0, new Minute(), 200); * <p>JFreeChart chart = ChartFactory.createTimeSeriesChart( "Multiple Axis Demo 1", "Time of * Day", "Primary Range Axis", dataset1, true, true, false ); * <p>chart.addSubtitle(new TextTitle("Four datasets and four range axes.")); XYPlot plot = * (XYPlot) chart.getPlot(); plot.setOrientation(PlotOrientation.VERTICAL); * <p>plot.getRangeAxis().setFixedDimension(15.0); * <p>// AXIS 2 NumberAxis axis2 = new NumberAxis("Range Axis 2"); * axis2.setFixedDimension(10.0); axis2.setAutoRangeIncludesZero(false); plot.setRangeAxis(1, * axis2); plot.setRangeAxisLocation(1, AxisLocation.BOTTOM_OR_LEFT); * <p>XYDataset dataset2 = createDataset("Series 2", 1000.0, new Minute(), 170); * plot.setDataset(1, dataset2); plot.mapDatasetToRangeAxis(1, 1); XYItemRenderer renderer2 = * new StandardXYItemRenderer(); plot.setRenderer(1, renderer2); * <p>// AXIS 3 NumberAxis axis3 = new NumberAxis("Range Axis 3"); plot.setRangeAxis(2, * axis3); * <p>XYDataset dataset3 = createDataset("Series 3", 10000.0, new Minute(), 170); * plot.setDataset(2, dataset3); plot.mapDatasetToRangeAxis(2, 2); XYItemRenderer renderer3 = * new StandardXYItemRenderer(); plot.setRenderer(2, renderer3); * <p>// AXIS 4 NumberAxis axis4 = new NumberAxis("Range Axis 4"); plot.setRangeAxis(3, * axis4); * <p>XYDataset dataset4 = createDataset("Series 4", 25.0, new Minute(), 200); * plot.setDataset(3, dataset4); plot.mapDatasetToRangeAxis(3, 3); * <p>XYItemRenderer renderer4 = new StandardXYItemRenderer(); plot.setRenderer(3, renderer4); * <p>ChartUtilities.applyCurrentTheme(chart); * <p>// change the series and axis colours after the theme has // been applied... * plot.getRenderer().setSeriesPaint(0, Color.black); renderer2.setSeriesPaint(0, Color.red); * axis2.setLabelPaint(Color.red); axis2.setTickLabelPaint(Color.red); * renderer3.setSeriesPaint(0, Color.blue); axis3.setLabelPaint(Color.blue); * axis3.setTickLabelPaint(Color.blue); renderer4.setSeriesPaint(0, Color.green); * axis4.setLabelPaint(Color.green); axis4.setTickLabelPaint(Color.green); * <p>return chart; } * <p>/** Creates a sample dataset. * @param name the dataset name. * @param base the starting value. * @param start the starting period. * @param count the number of values to generate. * @return The dataset. */ private static TimeSeries createDataset( String name, double base, RegularTimePeriod start, int count) { TimeSeries series = new TimeSeries(name, start.getClass()); RegularTimePeriod period = start; double value = base; for (int i = 0; i < count; i++) { series.add(period, value); period = period.next(); value = value * (1 + (Math.random() - 0.495) / 10.0); } return series; }
public void draw(double[] v) { TimeSeries data = new TimeSeries("symbol", FixedMillisecond.class); dataset1.addSeries(data); for (int i = 0; i < v.length; i++) { try { data.add(new FixedMillisecond(i), v[i]); } catch (Exception e) { System.out.println("Unresolved error"); // e.printStackTrace(); } } }
private static XYDataset createForceDataset(int i) { TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(); TimeSeries timeseries = new TimeSeries("Wind Force", org.jfree.data.time.Minute.class); Object obj = new Minute(); double d = 3D; for (int j = 0; j < i; j++) { timeseries.add(((RegularTimePeriod) (obj)), d); obj = ((RegularTimePeriod) (obj)).next(); d = Math.max(0.5D, d + (Math.random() - 0.5D) * 0.5D); } timeseriescollection.addSeries(timeseries); return timeseriescollection; }
/** * Gets the history entry for each day and transforms it to a <code>JFreeChart</code> entry. * * @param timeDifferenceHours */ protected TimeSeries getBurndownTimeSeries( List<IterationHistoryEntry> iterationHistoryEntries, LocalDate startDate, LocalDate endDate) { TimeSeries burndownSeries = new TimeSeries(BURNDOWN_SERIES_NAME); for (LocalDate iter = startDate.minusDays(1); iter.compareTo(endDate) < 0; iter = iter.plusDays(1)) { IterationHistoryEntry todayEntry = getHistoryEntryForDate(iterationHistoryEntries, iter); IterationHistoryEntry yesterdayEntry = getHistoryEntryForDate(iterationHistoryEntries, iter.minusDays(1)); if (isScopingDone(todayEntry)) { Pair<TimeSeriesDataItem, TimeSeriesDataItem> scopedEntries = getBurndownScopedDataItemForDay(yesterdayEntry, todayEntry); burndownSeries.add(scopedEntries.getFirst()); burndownSeries.add(scopedEntries.getSecond()); } burndownSeries.add(getBurndownDataItemForDay(todayEntry)); } return burndownSeries; }
private static XYDataset createDataset2A() { TimeSeries timeseries = new TimeSeries("Series 2"); timeseries.add(new Day(3, 3, 2002), 16853.200000000001D); timeseries.add(new Day(4, 3, 2002), 19642.299999999999D); timeseries.add(new Day(5, 3, 2002), 18253.5D); timeseries.add(new Day(6, 3, 2002), 15352.299999999999D); timeseries.add(new Day(7, 3, 2002), 13532D); timeseries.add(new Day(8, 3, 2002), 12635.299999999999D); timeseries.add(new Day(9, 3, 2002), 13998.200000000001D); timeseries.add(new Day(10, 3, 2002), 11943.200000000001D); timeseries.add(new Day(11, 3, 2002), 16943.900000000001D); timeseries.add(new Day(12, 3, 2002), 17843.200000000001D); timeseries.add(new Day(13, 3, 2002), 16495.299999999999D); timeseries.add(new Day(14, 3, 2002), 17943.599999999999D); timeseries.add(new Day(15, 3, 2002), 18500.700000000001D); timeseries.add(new Day(16, 3, 2002), 19595.900000000001D); TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(timeseries); timeseriescollection.setXPosition(TimePeriodAnchor.MIDDLE); return timeseriescollection; }
private static XYDataset createDataset2B() { TimeSeries timeseries = new TimeSeries("Series 2B"); timeseries.add(new Day(3, 3, 2002), 43.899999999999999D); timeseries.add(new Day(4, 3, 2002), 72.599999999999994D); timeseries.add(new Day(5, 3, 2002), 89.400000000000006D); timeseries.add(new Day(6, 3, 2002), 23.800000000000001D); timeseries.add(new Day(7, 3, 2002), 45D); timeseries.add(new Day(8, 3, 2002), 65.799999999999997D); timeseries.add(new Day(9, 3, 2002), 92.099999999999994D); timeseries.add(new Day(10, 3, 2002), 84.700000000000003D); timeseries.add(new Day(11, 3, 2002), 77.200000000000003D); timeseries.add(new Day(12, 3, 2002), 65.099999999999994D); timeseries.add(new Day(13, 3, 2002), 78.5D); timeseries.add(new Day(14, 3, 2002), 75.299999999999997D); timeseries.add(new Day(15, 3, 2002), 69.900000000000006D); timeseries.add(new Day(20, 3, 2002), 56.600000000000001D); TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(timeseries); timeseriescollection.setXPosition(TimePeriodAnchor.MIDDLE); return timeseriescollection; }
public void calcAverage1(int d, Date timestamp) { try { double v = 0; // List l1=x1.getItems(); for (int i = d; i < d + av1; i++) { v += x1.getValue(x1.getItemCount() - (av1 - i)).doubleValue(); } average1.add(new FixedMillisecond(timestamp), v / av1); } catch (Exception e) { // e.printStackTrace(); // System.out.println(timestamp.toString()); } }
private XYDataset createDataset(StockInfo stock, StockPriceType priceType) { TimeSeries timeSeries = new TimeSeries(stock.getTickerSymbol()); for (StockData sd : stock.getStockData()) { cal.setTime(sd.getDate()); int month = cal.get(Calendar.MONTH); int day = cal.get(Calendar.DAY_OF_MONTH); int year = cal.get(Calendar.YEAR); timeSeries.add(new Day(day, month + 1, year), priceType.get(sd)); // + 1 since calendar month starts at 0 } TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(timeSeries); return dataset; }
private static XYDatasetAndTotal createTotalDataset( String name, SortedMap<TimeAxisKey, DiffStat> aggregatedDiffstats) { int total = 0; TimeSeries totalSeries = new TimeSeries(name); for (Entry<TimeAxisKey, DiffStat> entry : aggregatedDiffstats.entrySet()) { TimeAxisKey timeAxisKey = entry.getKey(); DiffStat diffStat = entry.getValue(); RegularTimePeriod period = timeAxisKey.toPeriod(); total += diffStat.delta(); totalSeries.add(period, Integer.valueOf(total)); } TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(totalSeries); return new XYDatasetAndTotal(dataset, total); }
private void setDataByColumn(final IPentahoResultSet data) { // TODO Make this routine MDX friendly if (data == null) { noDataMessage = Messages.getInstance().getString("CHART.USER_NO_DATA_AVAILABLE"); // $NON-NLS-1$ return; // No data so we've got nothing to set // TODO come up with some sort of error strategy here. } boolean firstPass = true; String lastSeries = ""; // $NON-NLS-1$ String seriesName = ""; // $NON-NLS-1$ Class timePeriodClass = TimeSeriesCollectionChartDefinition.getTimePeriodClass(getDomainPeriodType()); Object[] rowData = data.next(); TimeSeries wrkSeries = null; while (rowData != null) { seriesName = (String) rowData[0]; if (firstPass || !seriesName.equalsIgnoreCase(lastSeries)) { if (!firstPass) { addSeries(wrkSeries); } wrkSeries = new TimeSeries(seriesName, timePeriodClass); lastSeries = seriesName; firstPass = false; } Date keyDate = getValidDate(rowData[1]); RegularTimePeriod regularTimePeriod = RegularTimePeriod.createInstance( timePeriodClass, keyDate, RegularTimePeriod.DEFAULT_TIME_ZONE); TimeSeriesDataItem timeSeriesDataItem = new TimeSeriesDataItem(regularTimePeriod, ((Number) rowData[2]).doubleValue()); if (wrkSeries != null) { wrkSeries.add(timeSeriesDataItem); } rowData = data.next(); } if (!firstPass) { addSeries(wrkSeries); } if ((data.getRowCount() > 0) && (this.getSeriesCount() <= 0)) { noDataMessage = Messages.getInstance().getString("CHART.USER_INCORRECT_DATA_FORMAT"); // $NON-NLS-1$ } }
private static XYDataset createDirectionDataset(int i) { TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(); TimeSeries timeseries = new TimeSeries("Wind Direction", org.jfree.data.time.Minute.class); Object obj = new Minute(); double d = 180D; for (int j = 0; j < i; j++) { timeseries.add(((RegularTimePeriod) (obj)), d); obj = ((RegularTimePeriod) (obj)).next(); d += (Math.random() - 0.5D) * 15D; if (d < 0.0D) { d += 360D; continue; } if (d > 360D) d -= 360D; } timeseriescollection.addSeries(timeseries); return timeseriescollection; }
private static XYDataset createDataset() { TimeSeries timeseries = new TimeSeries("Heart Rate"); timeseries.add(new Second(45, 6, 9, 1, 10, 2006), 143D); timeseries.add(new Second(33, 8, 9, 1, 10, 2006), 167D); timeseries.add(new Second(10, 10, 9, 1, 10, 2006), 189D); timeseries.add(new Second(19, 12, 9, 1, 10, 2006), 156D); timeseries.add(new Second(5, 15, 9, 1, 10, 2006), 176D); timeseries.add(new Second(12, 16, 9, 1, 10, 2006), 183D); timeseries.add(new Second(6, 18, 9, 1, 10, 2006), 138D); timeseries.add(new Second(11, 20, 9, 1, 10, 2006), 102D); TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(); timeseriescollection.addSeries(timeseries); return timeseriescollection; }
private TimeSeries convertToJFCTimeSeries( boolean interpolate, String name, TimeAddressable<Double> ts) throws KeyedException { Constructor<? extends RegularTimePeriod> constructor = getPeriodConstructor(ts.getTimeDomain()); TimeSeries timeSeries = new TimeSeries(name); for (Observation<Double> obs : ts) { Double value = obs.getValue(); if (ts.isMissing(value)) { if (interpolate) continue; } Date date = JavaDateUtil.toJavaDate(obs.getTime()); RegularTimePeriod period = null; try { period = constructor.newInstance(date); } catch (Exception e) { throw K.JFC_PERIOD_ERR.exception(e, date.toString()); } timeSeries.add(period, value); } return timeSeries; }
private static IntervalXYDataset createDataset() { TimeSeries timeseries = new TimeSeries("Series 1"); timeseries.add(new Day(1, 1, 2003), 54.299999999999997D); timeseries.add(new Day(2, 1, 2003), 20.300000000000001D); timeseries.add(new Day(3, 1, 2003), 43.399999999999999D); timeseries.add(new Day(4, 1, 2003), -12D); TimeSeries timeseries1 = new TimeSeries("Series 2"); timeseries1.add(new Day(1, 1, 2003), 8D); timeseries1.add(new Day(2, 1, 2003), 16D); timeseries1.add(new Day(3, 1, 2003), 21D); timeseries1.add(new Day(4, 1, 2003), 5D); TimeSeriesCollection timeseriescollection = new TimeSeriesCollection(); timeseriescollection.addSeries(timeseries); timeseriescollection.addSeries(timeseries1); return timeseriescollection; }
private void updateChartWithNewData(TimeSeriesCollection dataset) { String[] series = new String[] {"A", "B", "C"}; // If you want to get your time from somewhere else, change this line long timeNow = System.currentTimeMillis(); Random random = new Random(); Date now = new Date(timeNow); for (String seriesKey : series) { double value = 10 * random.nextInt(10); TimeSeries dataSeries = dataset.getSeries(seriesKey); if (dataSeries == null) { dataSeries = new TimeSeries(seriesKey); dataset.addSeries(dataSeries); } dataSeries.add(new Second(now), value); } }
/** * actually recalculates the first average (necessary when we change the average settings) * * @param d */ public void recalculateAverage1() { // average1=new TimeSeries("av1", FixedMillisecond.class); average1.delete(0, average1.getItemCount() - 1); for (int z = 0; z < x1.getItemCount(); z++) { try { double v = 0; // List l1=x1.getItems(); for (int i = z; i < z + av1; i++) { v += x1.getValue(x1.getItemCount() - (av1 - i)).doubleValue(); } average1.add(x1.getTimePeriod(z), v / av1); } catch (Exception e) { // e.printStackTrace(); // System.out.println(timestamp.toString()); } } }