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());
}
}
}
