/** Creates a dataset of type XYSeries */
public XYDataset convertDataSet() {
int size = 0; // Initialises a value for size
int sum = 0; // initialises a value for sum
int pos = 0; // initialises a value for position
int j = 0; // initialises a increment for the for loop
XYSeriesCollection dataset = new XYSeriesCollection();
XYSeries series = new XYSeries(super.GetTitle());
DataCell preVal = super.GetDataSet().GetCell(0, 0);
// Creates a new list for the found elements
super.m_foundElements = new ArrayList<String>();
for (int i = 0; i < super.GetDataSet().GetNumOfRows() - 1; i++) {
if (!super.isUnique(super.GetDataSet().GetCell(super.GetXColumnPosition(), i).toString())) {
for (j = pos; j < super.GetDataSet().GetNumOfRows() - 1; j++) {
if (preVal
.toString()
.equals(super.GetDataSet().GetCell(super.GetXColumnPosition(), j).toString())) {
// Check if datatype is a number
if (super.GetDataSet().GetCell(super.GetXColumnPosition(), j).GetDataType()
== DataType.INTEGER) {
sum += super.GetDataSet().GetCell(super.GetYColumnPosition(), j).GetInteger();
} else if (super.GetDataSet().GetCell(super.GetXColumnPosition(), j).GetDataType()
== DataType.DOUBLE) {
sum += super.GetDataSet().GetCell(super.GetYColumnPosition(), j).GetDouble();
}
}
}
super.m_foundElements.add(
super.GetDataSet().GetCell(super.GetXColumnPosition(), i).toString());
// Add to chart dataSet
series.add(sum, preVal.GetInteger());
preVal = super.GetDataSet().GetCell(super.GetXColumnPosition(), i++);
sum = 0; //
pos++;
}
}
for (j = pos; j < super.GetDataSet().GetNumOfRows() - 1; j++) {
if (super.m_foundElements
.get(super.m_foundElements.size() - 1)
.equals(super.GetDataSet().GetCell(super.GetXColumnPosition(), j).toString())) {
if (super.GetDataSet().GetCell(super.GetXColumnPosition(), j).GetDataType()
== DataType.INTEGER) {
sum += super.GetDataSet().GetCell(super.GetYColumnPosition(), j).GetInteger();
} else if (super.GetDataSet().GetCell(super.GetXColumnPosition(), j).GetDataType()
== DataType.DOUBLE) {
sum += super.GetDataSet().GetCell(super.GetYColumnPosition(), j).GetDouble();
}
}
}
series.add(sum, preVal.GetInteger());
dataset.addSeries(series);
return dataset;
}
/**
* precondition : 'attribute' MUST contain number values only
*
* @param cases
* @param attribute
* @return DefaultXYDataset with all values of 'attribute' against event numbers or timestamps.
*/
private XYSeriesCollection getDataAttributes(
String[] attributes, boolean byTime, double timesize) {
XYSeriesCollection result = new XYSeriesCollection();
for (int index = 0; index < attributes.length; index++) {
String attribute = attributes[index];
Integer i = 0;
XYSeries row = new XYSeries(attribute);
for (ProcessInstance pi : mylog.getInstances()) {
Integer x = 0; // count event number
Date begin = pi.getAuditTrailEntries().first().getTimestamp(); // starting
// time
// of
// process
// instance
for (AuditTrailEntry ate : pi.getListOfATEs()) {
if (ate.getAttributes().containsKey(attribute)) {
Double val;
val = Double.valueOf(ate.getAttributes().get(attribute));
if (byTime) {
row.add(timediff(begin, ate.getTimestamp()) / timesize, val.doubleValue());
} else {
row.add(x.doubleValue(), val.doubleValue());
}
}
x++; // event number in case
}
i++; // case number
}
result.addSeries(row);
}
return result;
}
/**
* @return a {@link org.jfree.data.xy.XYSeries} representing the distribution of traveled
* distances for the mode (histogramm), or null if the mode is unknown (only modes that
* generated events in the previous mobsim run are "known").
* @param step the width of the bins, in meters
* @param mode the mode to get the data for
*/
public XYSeries getTraveledXYsHistogram(final String mode, final double step) {
boolean autoSort = false;
boolean allowDuplicateXValues = true;
XYSeries output = new XYSeries(mode, autoSort, allowDuplicateXValues);
double[] modeRawData;
try {
modeRawData = this.rawData.get(mode).getElements();
} catch (NullPointerException e) {
return null;
}
Arrays.sort(modeRawData);
double currentUpperBound = step;
int count = 0;
for (double xyValue : modeRawData) {
if (xyValue < currentUpperBound) {
count++;
} else {
// add the previous bin to the plot
output.add(currentUpperBound - step, count);
// output.add(currentUpperBound, count);
currentUpperBound += step;
while (xyValue > currentUpperBound) {
output.add(currentUpperBound, 0d);
currentUpperBound += step;
}
count = 1;
}
}
// add the last count
output.add(currentUpperBound - step, count);
output.add(currentUpperBound, 0);
return output;
}
public void execute() {
// TODO Auto-generated method stub
// simply get the environment datamodel
dmodel = (StaticEnvDataModel) sim.getEnvDataModel();
double infected = getPercentInfected(dmodel);
synchronized (this) {
XYSeries series;
try {
series = data.getSeries("infected");
series.add(dmodel.time, infected);
} catch (org.jfree.data.UnknownKeyException e) {
series = new XYSeries("infected");
data.addSeries(series);
series.add(dmodel.time, infected);
}
if (dmodel.time % 100 == 0) {
// this will cause the gui to update?
updateChart();
}
}
}
/**
* Adds any unique x-values from 'series' to the dataset, and also adds any x-values that are in
* the dataset but not in 'series' to the series.
*
* @param series the series (<code>null</code> not permitted).
*/
private void updateXPoints(XYSeries series) {
if (series == null) {
throw new IllegalArgumentException("Null 'series' not permitted.");
}
HashSet seriesXPoints = new HashSet();
boolean savedState = this.propagateEvents;
this.propagateEvents = false;
for (int itemNo = 0; itemNo < series.getItemCount(); itemNo++) {
Number xValue = series.getX(itemNo);
seriesXPoints.add(xValue);
if (!this.xPoints.contains(xValue)) {
this.xPoints.add(xValue);
int seriesCount = this.data.size();
for (int seriesNo = 0; seriesNo < seriesCount; seriesNo++) {
XYSeries dataSeries = (XYSeries) this.data.get(seriesNo);
if (!dataSeries.equals(series)) {
dataSeries.add(xValue, null);
}
}
}
}
Iterator iterator = this.xPoints.iterator();
while (iterator.hasNext()) {
Number xPoint = (Number) iterator.next();
if (!seriesXPoints.contains(xPoint)) {
series.add(xPoint, null);
}
}
this.propagateEvents = savedState;
}
/**
* Creates and returns a sample dataset. The data was randomly generated.
*
* @return a sample dataset.
*/
private XYDataset createSampleData() {
XYSeries series = new XYSeries("Series 1");
series.add(2.0, 56.27);
series.add(3.0, 41.32);
series.add(4.0, 31.45);
series.add(5.0, 30.05);
series.add(6.0, 24.69);
series.add(7.0, 19.78);
series.add(8.0, 20.94);
series.add(9.0, 16.73);
series.add(10.0, 14.21);
series.add(11.0, 12.44);
XYSeriesCollection result = new XYSeriesCollection(series);
XYSeries series2 = new XYSeries("Series 2");
series2.add(11.0, 56.27);
series2.add(10.0, 41.32);
series2.add(9.0, 31.45);
series2.add(8.0, 30.05);
series2.add(7.0, 24.69);
series2.add(6.0, 19.78);
series2.add(5.0, 20.94);
series2.add(4.0, 16.73);
series2.add(3.0, 14.21);
series2.add(2.0, 12.44);
result.addSeries(series2);
return result;
}
protected void updateXYSerieses() throws MicroarrayException {
Iterable<Float> xValues = data.queryFeatures(xVar.getExpression()).asFloats();
Iterable<Float> yValues = data.queryFeatures(yVar.getExpression()).asFloats();
XYSeries series = new XYSeries("");
XYSeries selectionSeries = new XYSeries("");
Iterator<Float> xIterator = xValues != null ? xValues.iterator() : null;
int i = 0;
for (Float y : yValues) {
if (selectedIndexes.contains(i)) {
if (xIterator != null) {
selectionSeries.add(xIterator.next(), y);
} else {
selectionSeries.add(i, y);
}
} else {
if (xIterator != null) {
series.add(xIterator.next(), y);
} else {
series.add(i, y);
}
}
i++;
}
XYSeriesCollection dataset = new XYSeriesCollection();
dataset.addSeries(series);
dataset.addSeries(selectionSeries);
plot.setDataset(dataset);
}
/**
* A check for the datasetIndex and seriesIndex fields in the LegendItem returned by the
* getLegendItem() method.
*/
public void testGetLegendItemSeriesIndex() {
XYSeriesCollection d1 = new XYSeriesCollection();
XYSeries s1 = new XYSeries("S1");
s1.add(1.0, 1.1);
XYSeries s2 = new XYSeries("S2");
s2.add(1.0, 1.1);
d1.addSeries(s1);
d1.addSeries(s2);
XYSeriesCollection d2 = new XYSeriesCollection();
XYSeries s3 = new XYSeries("S3");
s3.add(1.0, 1.1);
XYSeries s4 = new XYSeries("S4");
s4.add(1.0, 1.1);
XYSeries s5 = new XYSeries("S5");
s5.add(1.0, 1.1);
d2.addSeries(s3);
d2.addSeries(s4);
d2.addSeries(s5);
XYDotRenderer r = new XYDotRenderer();
XYPlot plot = new XYPlot(d1, new NumberAxis("x"), new NumberAxis("y"), r);
plot.setDataset(1, d2);
/*JFreeChart chart =*/ new JFreeChart(plot);
LegendItem li = r.getLegendItem(1, 2);
assertEquals("S5", li.getLabel());
assertEquals(1, li.getDatasetIndex());
assertEquals(2, li.getSeriesIndex());
}
private void scatterPlot(
Map<Double, Map<String, Tuple<Double, Double>>> inputData, String outFile) {
String mode1 = travelModes[0];
String mode2 = travelModes[1];
XYSeries carFlow = new XYSeries(mode1 + " flow");
XYSeries bikeFlow = new XYSeries(mode2 + " flow");
XYSeries carSpeed = new XYSeries(mode1 + " speed");
XYSeries bikeSpeed = new XYSeries(mode2 + " speed");
for (double d : inputData.keySet()) {
carFlow.add(d, inputData.get(d).get(mode1).getFirst());
carSpeed.add(d, inputData.get(d).get(mode1).getSecond());
bikeFlow.add(d, inputData.get(d).get(mode2).getFirst());
bikeSpeed.add(d, inputData.get(d).get(mode2).getSecond());
}
// flow vs density
XYSeriesCollection flowDataset = new XYSeriesCollection();
flowDataset.addSeries(carFlow);
flowDataset.addSeries(bikeFlow);
NumberAxis flowAxis = new NumberAxis("Flow (PCU/h)");
flowAxis.setRange(0.0, 2100.0);
XYPlot plot1 = new XYPlot(flowDataset, null, flowAxis, new XYLineAndShapeRenderer(false, true));
plot1.setRangeAxisLocation(AxisLocation.BOTTOM_OR_LEFT);
// speed vs density
XYSeriesCollection speedDataset = new XYSeriesCollection();
speedDataset.addSeries(carSpeed);
speedDataset.addSeries(bikeSpeed);
NumberAxis speedAxis = new NumberAxis("Speed (m/s)");
speedAxis.setRange(0.0, 17.0);
XYPlot plot2 =
new XYPlot(speedDataset, null, speedAxis, new XYLineAndShapeRenderer(false, true));
plot2.setRangeAxisLocation(AxisLocation.TOP_OR_LEFT);
NumberAxis densityAxis = new NumberAxis("Overall density (PCU/km)");
densityAxis.setRange(0.0, 150.00);
CombinedDomainXYPlot plot = new CombinedDomainXYPlot(densityAxis);
plot.setGap(10.);
plot.add(plot1);
plot.add(plot2);
plot.setOrientation(PlotOrientation.VERTICAL);
JFreeChart chart =
new JFreeChart("Fundamental diagrams", JFreeChart.DEFAULT_TITLE_FONT, plot, true);
try {
ChartUtilities.saveChartAsPNG(new File(outFile), chart, 800, 600);
} catch (IOException e) {
throw new RuntimeException("Data is not plotted. Reason " + e);
}
}
/**
* Creates a series for testing.
*
* @return A series.
*/
private XYSeries createSeries1() {
XYSeries series1 = new XYSeries("Series 1", true, false);
series1.add(1.0, 1.0);
series1.add(2.0, 1.0);
series1.add(4.0, 1.0);
series1.add(5.0, 1.0);
return series1;
}
/**
* Creates a sample dataset.
*
* @param index the dataset index.
* @return A dataset.
*/
private XYDataset createDataset(int index) {
XYSeries series1 = new XYSeries("Series " + (index + 1));
series1.add(-10.0, -5.0);
series1.add(10.0, 5.0);
XYSeriesCollection dataset = new XYSeriesCollection();
dataset.addSeries(series1);
return dataset;
}
/**
* Creates a series for testing.
*
* @return A series.
*/
private XYSeries createSeries2() {
XYSeries series2 = new XYSeries("Series 2", true, false);
series2.add(2.0, 2.0);
series2.add(3.0, 2.0);
series2.add(4.0, 2.0);
series2.add(5.0, 2.0);
series2.add(6.0, 2.0);
return series2;
}
/** Checks that the auto-range for the range axis on an XYPlot is working as expected. */
@Test
public void testXYAutoRange2() {
XYSeries series = new XYSeries("Series 1");
series.add(1.0, 1.0);
series.add(2.0, 2.0);
series.add(3.0, 3.0);
XYSeriesCollection dataset = new XYSeriesCollection();
dataset.addSeries(series);
JFreeChart chart = ChartFactory.createScatterPlot("Test", "X", "Y", dataset);
XYPlot plot = (XYPlot) chart.getPlot();
NumberAxis axis = (NumberAxis) plot.getRangeAxis();
axis.setAutoRangeIncludesZero(false);
assertEquals(0.9, axis.getLowerBound(), EPSILON);
assertEquals(3.1, axis.getUpperBound(), EPSILON);
}
/**
* A demonstration application showing a scatter plot.
*
* @param title the frame title.
*/
public ScatterPlotDemo4(String title) {
super(title);
XYSeries series = new XYSeries("Average Weight");
series.add(-20.0, 20.0);
series.add(40.0, 25.0);
series.add(55.0, 50.0);
series.add(70.0, 65.0);
series.add(270.0, 65.0);
series.add(570.0, 55.0);
XYDataset data = new XYSeriesCollection(series);
JFreeChart chart =
ChartFactory.createScatterPlot(
"Scatter Plot Demo", "X", "Y", data, PlotOrientation.VERTICAL, true, true, false);
XYPlot plot = chart.getXYPlot();
LogElemRenderer render = new LogElemRenderer();
render.setDotWidth(25);
render.setDotHeight(25);
plot.setRenderer(render);
plot.setDomainCrosshairVisible(true);
plot.setRangeCrosshairVisible(true);
NumberAxis domainAxis = (NumberAxis) plot.getDomainAxis();
domainAxis.setAutoRangeIncludesZero(false);
ChartPanel chartPanel = new ChartPanel(chart);
chartPanel.setPreferredSize(new java.awt.Dimension(800, 470));
Border border =
BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(4, 4, 4, 4), BorderFactory.createEtchedBorder());
chartPanel.setBorder(border);
add(chartPanel);
JPanel dashboard = new JPanel(new BorderLayout());
dashboard.setBorder(BorderFactory.createEmptyBorder(0, 4, 4, 4));
// make the slider units "minutes"
slider = new JSlider(-200, 200, 0);
slider.setPaintLabels(true);
slider.setMajorTickSpacing(50);
slider.setPaintTicks(true);
slider.addChangeListener(this);
dashboard.add(slider);
add(dashboard, BorderLayout.SOUTH);
// setContentPane(chartPanel);
}
private XYDataset createDataset(String metricName) {
series = new XYSeriesCollection();
// For each collection of evaluations
for (int i = 0; i < evaluationsCollection.size(); i++) {
if (!set.contains(i)) {
List<AbstractEvaluation> evaluations = evaluationsCollection.get(i);
XYSeries newXYSerie = new XYSeries(queryNames.get(i));
int evalIndex = 0;
for (AbstractEvaluation eval : evaluations) {
if (evalIndex % reportFrecuency == 0) {
newXYSerie.add(eval.getLabeledSetSize(), eval.getMetricValue(metricName));
}
++evalIndex;
}
series.addSeries(newXYSerie);
}
}
// The series that belongs to passive learning is the last
if (passiveEvaluation != null) {
series.addSeries(createPassiveLearningSerie(metricName, evaluationsCollection.get(0)));
}
return series;
}
private static XYDataset createDataset(
String expName, String hostName, String metric, String category) throws Exception {
DBManager dba = new DBManager();
XYSeries series = new XYSeries(category);
String sql =
"SELECT time_s*100000+time_us as time, data from "
+ expName
+ "_proc WHERE instance = '"
+ category
+ "' and metric = '"
+ metric
+ "' and hostname = '"
+ hostName
+ "' ORDER BY time_s,time_us;";
// System.out.println(sql);
ArrayList resultList = dba.executeSql(sql);
for (int i = 0; i < resultList.size(); i++) {
HashMap hash = (HashMap) resultList.get(i);
double time = Double.parseDouble(hash.get("TIME").toString());
double data = Double.parseDouble(hash.get("DATA").toString());
System.out.println(time + " and " + data);
series.add(time, data);
}
XYSeriesCollection result = new XYSeriesCollection(series);
return result;
}
private XYDataset filterData(List<double[]> ds) {
this.setCursor(new Cursor(Cursor.WAIT_CURSOR));
double[] correlation = null;
double[] dblData1 = applyWindow(ds.get(0), (String) getTaperCB().getSelectedItem());
try {
if (ds.size() == 1) {
correlation = IstiUtilsMath.correlate(dblData1, dblData1);
} else {
double[] dblData2 = applyWindow(ds.get(1), (String) taperCB.getSelectedItem());
correlation = IstiUtilsMath.correlate(dblData1, dblData2);
}
} catch (IllegalArgumentException e) {
logger.error("IllegalArgumentException:", e);
}
logger.debug("correlation computed, size = " + correlation.length);
XYSeriesCollection dataset = new XYSeriesCollection();
XYSeries series = new XYSeries(seriesName);
double ampMax = 0;
int ampMaxPoint = -1;
for (int i = 0; i < correlation.length; i++) {
series.add(sampleRate * (i - correlation.length / 2) / 1000, correlation[i]);
if (Math.abs(correlation[i]) > ampMax) {
ampMax = Math.abs(correlation[i]);
ampMaxPoint = i;
}
}
dataset.addSeries(series);
getAmpMaxL().setText("Max Amplitude: " + dFormat.format(ampMax));
getLagTimeL()
.setText("Lag time: " + sampleRate * (ampMaxPoint - correlation.length / 2) / 1000 + " s");
this.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
return dataset;
}
@Override
protected void setChart() {
SeriesManager<Double, Double> sf = new SeriesManager<Double, Double>(intermediateData);
List<DataSeries<Double, Double>> seriesList = sf.getSeries();
DataSeries<Double, Double> series = seriesList.get(0);
List<SeriesPair<Double, Double>> values = series.getSeriesValues(Double.class, Double.class);
XYSeries deltaMassSeries = new XYSeries(series.getIdentifier());
for (SeriesPair<Double, Double> value : values) {
deltaMassSeries.add(value.getX(), value.getY());
}
XYSeriesCollection dataset = new XYSeriesCollection();
dataset.addSeries(deltaMassSeries);
chart =
ChartFactory.createXYLineChart(
getChartTitle(), // chart title
"Experimental m/z - Theoretical m/z", // x axis label
"Relative Frequency", // y axis label
dataset, // chartData
PlotOrientation.VERTICAL,
false, // include legend
true, // tooltips
false // urls
);
chart.addSubtitle(new TextTitle(getChartSubTitle()));
XYPlot plot = chart.getXYPlot();
plot.setDomainZeroBaselineVisible(true);
plot.setBackgroundAlpha(0f);
plot.setDomainGridlinePaint(Color.red);
plot.setRangeGridlinePaint(Color.blue);
}
/** Adds a value to the data series */
public void addValue(double x, double y) {
if (series != null) {
synchronized (series) {
series.add(x, y);
}
}
}
/**
* Sets the value of the existing point (abscissa, value) at index index to y. If the index is
* negative, does not do anything. If the index equals the index of the last element of the signal
* plus one, adds an element (index, y) to the signal at the index index. If the index is greateur
* than the index of the last element of the signal plus one, does not do anything.
*
* @param index index of the exsisting point. If the point does not exists, adds it
* @param y value to be given to the corresponding point (abscissa, value).
*/
public void setValueOf(int index, double y) {
if (index == this.getNbSamples()) {
data.add(index, y);
} else if ((index >= 0) && (index < this.getNbSamples())) {
data.updateByIndex(index, y);
}
}
private void crearImagen() {
XYSeries serie = new XYSeries("Serie");
Iterator<Double> iterator = ejercicio.getHistoricoSolucion().iterator();
for (int i = 0; i < ejercicio.getHistoricoSolucion().size(); i++) {
serie.add(i, iterator.next());
}
XYSeriesCollection coleccionSeries = new XYSeriesCollection();
coleccionSeries.addSeries(serie);
JFreeChart chart =
ChartFactory.createXYLineChart(
"Comportamiento Simulated Annealing",
"Ciclo",
"Solucion",
coleccionSeries,
PlotOrientation.VERTICAL,
false,
false,
true);
ChartPanel panel = new ChartPanel(chart);
panel.setMouseZoomable(true);
this.add(panel);
}
private void writeTimeSpentScalabilitySummaryChart() {
List<XYSeries> seriesList =
new ArrayList<XYSeries>(plannerBenchmarkResult.getSolverBenchmarkResultList().size());
for (SolverBenchmarkResult solverBenchmarkResult :
plannerBenchmarkResult.getSolverBenchmarkResultList()) {
String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
XYSeries series = new XYSeries(solverLabel);
for (SingleBenchmarkResult singleBenchmarkResult :
solverBenchmarkResult.getSingleBenchmarkResultList()) {
if (singleBenchmarkResult.hasAllSuccess()) {
long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
long timeMillisSpent = singleBenchmarkResult.getTimeMillisSpent();
series.add((Long) problemScale, (Long) timeMillisSpent);
}
}
seriesList.add(series);
}
XYPlot plot =
createScalabilityPlot(
seriesList,
"Problem scale",
NumberFormat.getInstance(locale),
"Time spent",
new MillisecondsSpentNumberFormat(locale));
JFreeChart chart =
new JFreeChart(
"Time spent scalability summary (lower is better)",
JFreeChart.DEFAULT_TITLE_FONT,
plot,
true);
timeSpentScalabilitySummaryChartFile =
writeChartToImageFile(chart, "timeSpentScalabilitySummary");
}
private void writeAverageCalculateCountPerSecondSummaryChart() {
List<XYSeries> seriesList =
new ArrayList<XYSeries>(plannerBenchmarkResult.getSolverBenchmarkResultList().size());
for (SolverBenchmarkResult solverBenchmarkResult :
plannerBenchmarkResult.getSolverBenchmarkResultList()) {
String solverLabel = solverBenchmarkResult.getNameWithFavoriteSuffix();
XYSeries series = new XYSeries(solverLabel);
for (SingleBenchmarkResult singleBenchmarkResult :
solverBenchmarkResult.getSingleBenchmarkResultList()) {
if (singleBenchmarkResult.hasAllSuccess()) {
long problemScale = singleBenchmarkResult.getProblemBenchmarkResult().getProblemScale();
long averageCalculateCountPerSecond =
singleBenchmarkResult.getAverageCalculateCountPerSecond();
series.add((Long) problemScale, (Long) averageCalculateCountPerSecond);
}
}
seriesList.add(series);
}
XYPlot plot =
createScalabilityPlot(
seriesList,
"Problem scale",
NumberFormat.getInstance(locale),
"Average calculate count per second",
NumberFormat.getInstance(locale));
JFreeChart chart =
new JFreeChart(
"Average calculate count summary (higher is better)",
JFreeChart.DEFAULT_TITLE_FONT,
plot,
true);
averageCalculateCountSummaryChartFile =
writeChartToImageFile(chart, "averageCalculateCountSummary");
}
public static XYSeries getXY(String url) {
XYSeries xyseries = new XYSeries("");
Path path = new Path(url);
Configuration conf = HUtils.getConf();
SequenceFile.Reader reader = null;
try {
reader =
new SequenceFile.Reader(
conf, Reader.file(path), Reader.bufferSize(4096), Reader.start(0));
DoubleArrStrWritable dkey =
(DoubleArrStrWritable) ReflectionUtils.newInstance(reader.getKeyClass(), conf);
DoublePairWritable dvalue =
(DoublePairWritable) ReflectionUtils.newInstance(reader.getValueClass(), conf);
while (reader.next(dkey, dvalue)) { // 循环读取文件
xyseries.add(dvalue.getFirst(), dvalue.getSecond());
}
} catch (Exception e) {
e.printStackTrace();
} finally {
IOUtils.closeStream(reader);
}
return xyseries;
}
private boolean plotCorrectionData() {
plot3d.removeAllPlots();
XYSeries series;
XYPlot plot = chartPanel.getChart().getXYPlot();
XYSeriesCollection lineDataset = (XYSeriesCollection) plot.getDataset(0);
DecimalFormat df = new DecimalFormat(".00");
String val;
int i = 0;
int j = 0;
if (!Utils.isTableEmpty(corrTable)) {
try {
for (i = 1; i < corrTable.getColumnCount(); ++i) {
val = corrTable.getValueAt(0, i).toString();
series = new XYSeries(df.format(Double.valueOf(val)));
for (j = 1; j < corrTable.getRowCount(); ++j) {
if (corrTable.getValueAt(j, i) != null) {
val = corrTable.getValueAt(j, i).toString();
if (!val.isEmpty())
series.add(
Double.valueOf(corrTable.getValueAt(j, 0).toString()), Double.valueOf(val));
}
}
if (series.getItemCount() > 0) {
corrData.add(series);
series.setDescription(series.getKey().toString());
lineDataset.addSeries(series);
}
}
plot.getDomainAxis(0).setAutoRange(true);
plot.getRangeAxis(0).setAutoRange(true);
plot.getDomainAxis(0).setLabel(xAxisName);
plot.getRangeAxis(0).setLabel(yAxisName);
plot.getRenderer(0).setSeriesVisible(0, false);
double[] x = new double[xAxisArray.size()];
for (i = 0; i < xAxisArray.size(); ++i) x[i] = xAxisArray.get(i);
double[] y = new double[yAxisArray.size()];
for (i = 0; i < yAxisArray.size(); ++i) y[i] = yAxisArray.get(i);
double[][] z = Utils.doubleZArray(corrTable, x, y);
Color[][] colors = Utils.generateTableColorMatrix(corrTable, 1, 1);
plot3d.addGridPlot("Average Error % Plot", colors, x, y, z);
} catch (NumberFormatException e) {
logger.error(e);
JOptionPane.showMessageDialog(
null,
"Error parsing number from "
+ corrTableName
+ " table, cell("
+ i
+ " : "
+ j
+ "): "
+ e,
"Error",
JOptionPane.ERROR_MESSAGE);
return false;
}
}
return true;
}
/**
* Looks for the element of the given abscissa and sets its value to ordiante. If there is no
* points existing with the given abcisssa, adds a point (abscissa, ordinate) to the signal.
* (actually, this method does the exact same thing as addElement).
*
* @param abscissa abscissa of the considered point
* @param ordinate value to add or update in the signal
*/
public void setElement(double abscissa, double ordinate) {
int index = data.indexOf(abscissa);
if (index < 0) {
data.add(abscissa, ordinate);
} else {
data.updateByIndex(index, ordinate);
}
}
public void setPath(List<XYPoint> xyList) {
mIdeal.clear();
clearActuals();
for (int i = 0; i < xyList.size(); ++i) {
mIdeal.add(xyList.get(i).mX, xyList.get(i).mY);
}
}
private JFreeChart getGraphic(final ModeData modeData, final String modeName) {
final XYSeriesCollection xyData = new XYSeriesCollection();
final XYSeries departuresSerie = new XYSeries("departures", false, true);
final XYSeries arrivalsSerie = new XYSeries("arrivals", false, true);
final XYSeries onRouteSerie = new XYSeries("en route", false, true);
int onRoute = 0;
for (int i = 0; i < modeData.countsDep.length; i++) {
onRoute = onRoute + modeData.countsDep[i] - modeData.countsArr[i] - modeData.countsStuck[i];
double hour = i * this.binSize / 60.0 / 60.0;
departuresSerie.add(hour, modeData.countsDep[i]);
arrivalsSerie.add(hour, modeData.countsArr[i]);
onRouteSerie.add(hour, onRoute);
}
xyData.addSeries(departuresSerie);
xyData.addSeries(arrivalsSerie);
xyData.addSeries(onRouteSerie);
final JFreeChart chart =
ChartFactory.createXYStepChart(
"Leg Histogram, " + modeName + ", it." + this.iteration,
"time",
"# vehicles",
xyData,
PlotOrientation.VERTICAL,
true, // legend
false, // tooltips
false // urls
);
XYPlot plot = chart.getXYPlot();
final CategoryAxis axis1 = new CategoryAxis("hour");
axis1.setTickLabelFont(new Font("SansSerif", Font.PLAIN, 7));
plot.setDomainAxis(new NumberAxis("time"));
plot.getRenderer().setSeriesStroke(0, new BasicStroke(2.0f));
plot.getRenderer().setSeriesStroke(1, new BasicStroke(2.0f));
plot.getRenderer().setSeriesStroke(2, new BasicStroke(2.0f));
plot.setBackgroundPaint(Color.white);
plot.setRangeGridlinePaint(Color.gray);
plot.setDomainGridlinePaint(Color.gray);
return chart;
}
/**
* @param valueSource
* @param plotInstance
* @param autoWidthFraction If this value is greater than 0, an auto width for the intervals is
* calculated such that the intervals nearest to each other touch. This value is then
* multiplied with the value of autoWidthFtraction. If unset, the intervals have width 0.
* @param allowDuplicates
* @param sortByDomain if true, the data is sorted by domain values (useful for bar and area
* charts)
* @return
* @throws ChartPlottimeException
*/
public static XYSeriesCollection createXYSeriesCollection(
ValueSource valueSource,
PlotInstance plotInstance,
double autoWidthFraction,
boolean allowDuplicates,
boolean sortByDomain)
throws ChartPlottimeException {
XYSeriesCollection xyDataset = new XYSeriesCollection();
if (autoWidthFraction > 0) {
xyDataset.setAutoWidth(true);
} else {
xyDataset.setAutoWidth(false);
xyDataset.setIntervalWidth(0);
}
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
// Loop over group cells and add data to dataset
for (GroupCellKeyAndData groupCellKeyAndData : dataForAllGroupCells) {
GroupCellKey groupCellKey = groupCellKeyAndData.getKey();
GroupCellData groupCellData = groupCellKeyAndData.getData();
String seriesName =
generateSeriesName(
valueSource, groupCellKey, plotInstance.getCurrentPlotConfigurationClone());
XYSeries series = new XYSeries(seriesName, sortByDomain, allowDuplicates);
Map<PlotDimension, double[]> dataForUsageType =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
int rowCount = dataForUsageType.get(PlotDimension.DOMAIN).length;
double[] xValues = dataForUsageType.get(PlotDimension.DOMAIN);
double[] yValues = dataForUsageType.get(PlotDimension.VALUE);
try {
// Loop over rows and add data to series
for (int row = 0; row < rowCount; ++row) {
double x = xValues[row];
double y = yValues[row];
if (!Double.isNaN(x)) {
series.add(x, y);
}
}
} catch (SeriesException e) {
throw new ChartPlottimeException(
"duplicate_value", valueSource.toString(), PlotDimension.DOMAIN.getName());
}
xyDataset.addSeries(series);
}
// intervals should not touch each other, so decrease auto width.
if (xyDataset.getIntervalWidth() > 0) {
xyDataset.setIntervalWidth(xyDataset.getIntervalWidth() * autoWidthFraction);
}
return xyDataset;
}
/**
* Add sample to a series
*
* @param x Abcissa
* @param y Ordinate
* @param seriesName Series name
*/
@Override
public void addSample(double x, double y, String seriesName) {
for (XYSeries serie : seriesList) {
if (serie.getKey().toString().equals(seriesName)) {
serie.add(x, y);
break;
}
}
}