/** * Creates a new axis. * * @param label the axis label (<code>null</code> permitted). * @param first the first time period in the axis range (<code>null</code> not permitted). * @param last the last time period in the axis range (<code>null</code> not permitted). * @param timeZone the time zone (<code>null</code> not permitted). * @param locale the locale (<code>null</code> not permitted). * @since 1.0.13 */ public PeriodAxis( String label, RegularTimePeriod first, RegularTimePeriod last, TimeZone timeZone, Locale locale) { super(label, null); if (timeZone == null) { throw new IllegalArgumentException("Null 'timeZone' argument."); } if (locale == null) { throw new IllegalArgumentException("Null 'locale' argument."); } this.first = first; this.last = last; this.timeZone = timeZone; this.locale = locale; this.calendar = Calendar.getInstance(timeZone, locale); this.first.peg(this.calendar); this.last.peg(this.calendar); this.autoRangeTimePeriodClass = first.getClass(); this.majorTickTimePeriodClass = first.getClass(); this.minorTickMarksVisible = false; this.minorTickTimePeriodClass = RegularTimePeriod.downsize(this.majorTickTimePeriodClass); setAutoRange(true); this.labelInfo = new PeriodAxisLabelInfo[2]; this.labelInfo[0] = new PeriodAxisLabelInfo(Month.class, new SimpleDateFormat("MMM", locale)); this.labelInfo[1] = new PeriodAxisLabelInfo(Year.class, new SimpleDateFormat("yyyy", locale)); }
/** * Adds a data item to the series. * * @param period the period. * @param open the open-value. * @param high the high-value. * @param low the low-value. * @param close the close-value. */ public void add(RegularTimePeriod period, double open, double high, double low, double close) { if (getItemCount() > 0) { OHLCItem item0 = (OHLCItem) this.getDataItem(0); if (!period.getClass().equals(item0.getPeriod().getClass())) { throw new IllegalArgumentException("Can't mix RegularTimePeriod class types."); } } super.add(new OHLCItem(period, open, high, low, close), true); }
/** * Adds a data item to the series. * * @param period the period. * @param stochasticOscillator the StochasticOscillator. */ public void add(RegularTimePeriod period, BigDecimal stochasticOscillator) { if (!this.isEmpty()) { StochasticOscillatorItem item0 = (StochasticOscillatorItem) this.getDataItem(0); if (!period.getClass().equals(item0.getPeriod().getClass())) { throw new IllegalArgumentException("Can't mix RegularTimePeriod class types."); } } super.add(new StochasticOscillatorItem(period, stochasticOscillator), true); }
/** * Adds a data item to the series. * * @param period the period. * @param MACD the MACD. */ public void add( RegularTimePeriod period, BigDecimal MACD, BigDecimal signalLine, BigDecimal MACDHistogram) { if (!this.isEmpty()) { MACDItem item0 = (MACDItem) this.getDataItem(0); if (!period.getClass().equals(item0.getPeriod().getClass())) { throw new IllegalArgumentException("Can't mix RegularTimePeriod class types."); } } super.add(new MACDItem(period, MACD, signalLine, MACDHistogram), true); }
/** * 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; }
/** * 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 XYDataset createDataset(String name, double base, RegularTimePeriod start, int count) { this.series = new TimeSeries(name, start.getClass()); RegularTimePeriod period = start; double value = base; for (int i = 0; i < count; i++) { this.series.add(period, value); period = period.next(); value = value * (1 + (Math.random() - 0.495) / 10.0); } TimeSeriesCollection dataset = new TimeSeriesCollection(); dataset.addSeries(this.series); return dataset; }
/** * Tests the correct output of a DataSet to a TimeSeries by outputting it, then iterating through * TimeSeries object checking the correct values were stored/output. */ public void testOutput() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, InstantiationException { // Constants used to determine size of test int NUMBER_OF_TIME_PERIODS = 10; String TIME_VARIABLE = "t"; // Set up array for expected results double expectedValue[] = new double[NUMBER_OF_TIME_PERIODS]; // We'll set up periods starting from today RegularTimePeriod period = new Day(); // Create a test DataSet for output // - note that only one independent variable (the time variable) // will be output. This is expected. DataSet dataSet = new DataSet(); dataSet.setTimeVariable(TIME_VARIABLE); for (int d = 0; d < NUMBER_OF_TIME_PERIODS; d++) { double value = (double) d; DataPoint obs = new Observation(value); obs.setIndependentValue(TIME_VARIABLE, period.getMiddleMillisecond()); dataSet.add(obs); period = period.next(); expectedValue[d] = value; } assertEquals( "Checking only one independent variable exists in dataSet", 1, dataSet.getIndependentVariables().length); assertEquals( "Checking dataSet has correct number of entries", NUMBER_OF_TIME_PERIODS, dataSet.size()); // Create TimeSeriesOutputter and use it to output dataSet TimeSeries timeSeries = new TimeSeries("test"); TimeSeriesOutputter outputter = new TimeSeriesOutputter(timeSeries, period.getClass()); outputter.output(dataSet); assertEquals( "Checking number of items in time series", NUMBER_OF_TIME_PERIODS, timeSeries.getItemCount()); // Reset period to start checking from today onwards period = new Day(); for (int d = 0; d < NUMBER_OF_TIME_PERIODS; d++) { TimeSeriesDataItem dataItem = timeSeries.getDataItem(d); period = dataItem.getPeriod(); assertNotNull("Checking time period", period); long timeValue = period.getMiddleMillisecond(); assertTrue( "Checking time periods match", (double) timeValue >= period.getFirstMillisecond() && (double) timeValue <= period.getLastMillisecond()); assertEquals( "Checking values for period " + dataItem.getPeriod() + " match", expectedValue[d], dataItem.getValue().doubleValue(), TOLERANCE); period = period.next(); } }
private void addData( JFreeChart chart, DSLAMSource source, Timeinterval time, Serializable filter, Properties properties, Map<String, Object> colorScheme, Properties outputProperties) throws IOException { if (chart != null) { PerformanceCounterDataCollection cData = null; long dataSize = 0; try { cData = getPerformanceCounterDataCollection(source, time, filter, properties, outputProperties); Collection<PerformanceCounterData> data = null; Date d0 = null; // first timestamp for data Date d1 = null; // last timestamp for data RegularTimePeriod time0 = null; if (cData != null) { data = cData.getData(); { int l = data.size(); outputProperties.setProperty("data.count", Integer.toString(l)); } if (data != null && data.size() > 0) { dataSize = data.size(); // Set 'd0': { // TODO: Avoid assumption "data is sorted"! PerformanceCounterData e = data.iterator().next(); d0 = e.getTimestamp(); } // Set 'd1': { // TODO: Avoid assumption "data is sorted"! for (PerformanceCounterData e : data) { d1 = e.getTimestamp(); } } time0 = createRegularTimePeriod(d0); } } XYPlot plot = chart.getXYPlot(); // Set the first dataset: { TimeSeriesCollection dataset = new TimeSeriesCollection(); List<Paint> seriesPaint = new ArrayList<Paint>(); List<Stroke> seriesStroke = new ArrayList<Stroke>(); // Add series 'ES': { if (data != null && data.size() > 0) { TimeSeries series = new TimeSeries("ES", time0.getClass()); for (PerformanceCounterData e : data) { Date d = e.getTimestamp(); RegularTimePeriod timePeriod = createRegularTimePeriod(d); // Add point: { int value = getES(e); addOrUpdate(series, timePeriod, (double) value); } } seriesPaint.add((Paint) colorScheme.get("color.counter.es")); seriesStroke.add(STROKE_COUNTER_ES); dataset.addSeries(series); } } // Add series 'SES': { if (data != null && data.size() > 0) { TimeSeries series = new TimeSeries("SES", time0.getClass()); for (PerformanceCounterData e : data) { Date d = e.getTimestamp(); RegularTimePeriod timePeriod = createRegularTimePeriod(d); // Add point: { int value = getSES(e); addOrUpdate(series, timePeriod, (double) value); } } seriesPaint.add((Paint) colorScheme.get("color.counter.ses")); seriesStroke.add(STROKE_COUNTER_SES); dataset.addSeries(series); } } // Add series 'US': { if (data != null && data.size() > 0) { TimeSeries series = new TimeSeries("US", time0.getClass()); for (PerformanceCounterData e : data) { Date d = e.getTimestamp(); RegularTimePeriod timePeriod = createRegularTimePeriod(d); // Add point: { int value = getUS(e); addOrUpdate(series, timePeriod, (double) value); } } seriesPaint.add((Paint) colorScheme.get("color.counter.us")); seriesStroke.add(STROKE_COUNTER_US); dataset.addSeries(series); } } // superspeed { if (data != null && data.size() > 0) { TimeSeries series = new TimeSeries("LEFTRS", time0.getClass()); for (PerformanceCounterData e : data) { Date d = e.getTimestamp(); RegularTimePeriod timePeriod = createRegularTimePeriod(d); { int value = getPreviousLEFTRS(e); addOrUpdate(series, timePeriod, (double) value); } } seriesPaint.add((Paint) colorScheme.get("color.counter.previousleftrs")); seriesStroke.add(STROKE_COUNTER_US); dataset.addSeries(series); } } // ends { if (data != null && data.size() > 0) { boolean showLinearCurve = getShowLinearCurve(); if (showLinearCurve) { // Add series for a linear curve: { TimeSeries series = new TimeSeries("Linear", time0.getClass()); long t0 = d0.getTime(); long t1 = d1.getTime(); if (t0 < t1) { long timeX = 15 * 60 * 1000; // 15 minutes intervals // TODO: Read length of intervals from obtained data! double value0 = 0; double value1 = 900; // TODO: Read '900' from obtained data! long timeDelta = t1 - t0; double valueDelta = value1 - value0; long t = t0; int i = 0; while (t <= t1) { Date d = new Date(t); RegularTimePeriod timePeriod = createRegularTimePeriod(d); double value = value0 + ((t - t0) * valueDelta) / timeDelta; // Add point: { addOrUpdate(series, timePeriod, (double) value); } t += timeX; i += 1; } } seriesPaint.add(Color.red); seriesStroke.add(STROKE_COUNTER_DEFAULT); dataset.addSeries(series); } } } } setDefaultRenderer(chart, colorScheme, 0, seriesPaint, seriesStroke); plot.setDataset(0, dataset); plot.mapDatasetToRangeAxis(0, 0); } } finally { if (cData != null) { cData.dispose(); cData = null; } } if (outputProperties != null) { outputProperties.setProperty("data.count", Long.toString(dataSize)); } } }