private static void configureBarRenderer(
BarRenderer renderer, ValueSource valueSource, PlotInstance plotInstance) {
StandardBarPainter barPainter = new StandardBarPainter();
renderer.setBarPainter(barPainter);
renderer.setGradientPaintTransformer(null);
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
int seriesCount = valueSourceData.getSeriesCount();
DimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfig colorDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.COLOR);
SeriesFormat seriesFormat = valueSource.getSeriesFormat();
// Loop all series and set series format.
// Format based on dimension configs will be set later on in initFormatDelegate().
for (int seriesIdx = 0; seriesIdx < seriesCount; ++seriesIdx) {
// configure series paint if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, colorDimensionConfig)) {
renderer.setSeriesPaint(seriesIdx, seriesFormat.getAreaFillPaint());
}
// configure general style of the bars
renderer.setShadowVisible(false);
renderer.setSeriesOutlinePaint(seriesIdx, PlotConfiguration.DEFAULT_SERIES_OUTLINE_PAINT);
}
renderer.setDrawBarOutline(true);
}
/**
* @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;
}
public static DefaultStatisticalCategoryDataset createDefaultStatisticalCategoryDataset(
ValueSource valueSource, PlotInstance plotInstance) throws ChartPlottimeException {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
DefaultStatisticalCategoryDataset dataset = new DefaultStatisticalCategoryDataset();
DefaultDimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfigData domainConfigData =
plotInstance.getPlotData().getDimensionConfigData(domainConfig);
// Loop all 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());
Map<PlotDimension, double[]> mainSeriesData =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
double[] xValues = mainSeriesData.get(PlotDimension.DOMAIN);
double[] yValues = mainSeriesData.get(PlotDimension.VALUE);
double[] yErrorValues = valueSourceData.getAbsoluteUtilityValues(groupCellKeyAndData, true);
if (yErrorValues == null) {
throw new ChartPlottimeException(
"undefined_series", valueSource.toString(), SeriesUsageType.INDICATOR_1);
}
// this dataset does not support unsymmetric errors
if (groupCellData.getDataForUsageType(SeriesUsageType.INDICATOR_2) != null) {
throw new ChartPlottimeException(
"unsymmetric_utility_not_supported", valueSource.toString());
}
int rowCount = xValues.length;
// Loop all rows and add data to series
double xValue;
double yValue;
double yErrorValue;
String xString;
for (int row = 0; row < rowCount; ++row) {
xValue = xValues[row];
xString = domainConfigData.getStringForValue(xValue);
yValue = yValues[row];
yErrorValue = yErrorValues[row] - yValue;
dataset.add(yValue, yErrorValue, seriesName, xString);
}
}
return dataset;
}
/**
* Same as {@link #createDefaultMultiValueCategoryDataset(ValueSource, PlotConfiguration)}, but
* instead of storing only the values it stores pairs in the lists, where the first value is the
* data value, and the second value holds the index of the value in the series in valueSource.
*
* <p>Must be used for the FormattedScatterRenderer.
*
* @throws ChartPlottimeException
*/
public static DefaultMultiValueCategoryDataset createAnnotatedDefaultMultiValueCategoryDataset(
ValueSource valueSource, PlotInstance plotInstance) throws ChartPlottimeException {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
DefaultMultiValueCategoryDataset dataset = new DefaultMultiValueCategoryDataset();
DefaultDimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfigData domainConfigData =
plotInstance.getPlotData().getDimensionConfigData(domainConfig);
// Loop all group cells and add data to dataset
for (GroupCellKeyAndData groupCellKeyAndData : dataForAllGroupCells) {
// the DefaultMultiValueCategoryDataset expects a List of values for each domain value. This
// map
// maps domain values to lists and is filled while we iterate through all data value below.
Map<Double, List<Pair<Double, Integer>>> valueListsForDomainValues =
new HashMap<Double, List<Pair<Double, Integer>>>();
for (Double value : domainConfigData.getDistinctValues()) {
valueListsForDomainValues.put(value, new LinkedList<Pair<Double, Integer>>());
}
GroupCellKey groupCellKey = groupCellKeyAndData.getKey();
GroupCellData groupCellData = groupCellKeyAndData.getData();
String seriesName =
generateSeriesName(
valueSource, groupCellKey, plotInstance.getCurrentPlotConfigurationClone());
Map<PlotDimension, double[]> mainSeriesData =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
double[] xValues = mainSeriesData.get(PlotDimension.DOMAIN);
double[] yValues = mainSeriesData.get(PlotDimension.VALUE);
int rowCount = xValues.length;
// Loop all rows and add data into map
double xValue;
double yValue;
String xString;
for (int row = 0; row < rowCount; ++row) {
xValue = xValues[row];
yValue = yValues[row];
Pair<Double, Integer> valueRowNumberPair = new Pair<Double, Integer>(yValue, row);
valueListsForDomainValues.get(xValue).add(valueRowNumberPair);
}
for (Double value : domainConfigData.getDistinctValues()) {
xString = domainConfigData.getStringForValue(value);
dataset.add(valueListsForDomainValues.get(value), seriesName, xString);
}
}
return dataset;
}
public static XYItemRenderer[] createXYDifferenceRenderers(
ValueSource valueSource, PlotInstance plotInstance) {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
FormattedXYDifferenceRenderer[] renderers =
new FormattedXYDifferenceRenderer[valueSourceData.getSeriesCount()];
for (int seriesIdx = 0; seriesIdx < valueSourceData.getSeriesCount(); ++seriesIdx) {
FormattedXYDifferenceRenderer renderer = new FormattedXYDifferenceRenderer(seriesIdx);
configureXYDifferenceRenderer(
renderer, valueSource, plotInstance.getCurrentPlotConfigurationClone());
initFormatDelegate(valueSource, seriesIdx, renderer, plotInstance);
renderers[seriesIdx] = renderer;
}
return renderers;
}
public static DefaultTableXYDataset createDefaultTableXYDataset(
ValueSource valueSource, PlotInstance plotInstance) throws ChartPlottimeException {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
DefaultTableXYDataset dataset = new DefaultTableXYDataset();
// Loop all group cells and add data to dataset
for (GroupCellKeyAndData groupCellKeyAndData : dataForAllGroupCells) {
GroupCellKey groupCellKey = groupCellKeyAndData.getKey();
GroupCellData groupCellData = groupCellKeyAndData.getData();
Map<PlotDimension, double[]> dataForUsageType =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
double[] xValues = dataForUsageType.get(PlotDimension.DOMAIN);
double[] yValues = dataForUsageType.get(PlotDimension.VALUE);
int rowCount = xValues.length;
String seriesName =
generateSeriesName(
valueSource, groupCellKey, plotInstance.getCurrentPlotConfigurationClone());
XYSeries series = new XYSeries(seriesName, false, false);
// Loop all rows and add data to series
double x;
double y;
for (int row = 0; row < rowCount; ++row) {
x = xValues[row];
y = yValues[row];
try {
if (!Double.isNaN(x)) {
series.add(
x, y,
false); // false means: do not notify. Since we are currently initializing, this is
// not necessary and saves us some fractions of a second
}
} catch (SeriesException e) {
throw new ChartPlottimeException(
"duplicate_value", valueSource.toString(), PlotDimension.DOMAIN.getName());
}
}
dataset.addSeries(series);
}
dataset.setAutoWidth(true);
return dataset;
}
private static void addSeriesToDefaultXYDataset(
ValueSource valueSource, int seriesIdx, PlotInstance plotInstance, DefaultXYDataset dataset)
throws ChartPlottimeException {
final int xIdx = 0;
final int yIdx = 1;
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
GroupCellKeyAndData groupCellKeyAndData =
dataForAllGroupCells.getGroupCellKeyAndData(seriesIdx);
GroupCellKey groupCellKey = groupCellKeyAndData.getKey();
GroupCellData groupCellData = groupCellKeyAndData.getData();
// create series name
GroupCellKey groupCellKeyClone = (GroupCellKey) groupCellKey.clone();
String seriesName =
generateSeriesName(
valueSource, groupCellKeyClone, plotInstance.getCurrentPlotConfigurationClone());
String differenceName = "__&%" + seriesName + "%&__";
Map<PlotDimension, double[]> mainData =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
double[] xValues = mainData.get(PlotDimension.DOMAIN);
double[] yValues = mainData.get(PlotDimension.VALUE);
double[][] mainSeries = new double[2][xValues.length];
mainSeries[xIdx] = xValues;
mainSeries[yIdx] = yValues;
dataset.addSeries(seriesName, mainSeries);
if (valueSource.getSeriesFormat().getUtilityUsage() == IndicatorType.DIFFERENCE) {
double[] differenceValues =
valueSourceData.getAbsoluteUtilityValues(groupCellKeyAndData, true);
if (differenceValues == null) {
throw new ChartPlottimeException(
"undefined_series", valueSource.toString(), SeriesUsageType.INDICATOR_1);
}
double[][] differenceSeries = new double[2][xValues.length];
differenceSeries[xIdx] = xValues;
differenceSeries[yIdx] = differenceValues;
dataset.addSeries(differenceName, differenceSeries);
}
}
public static XYItemRenderer createStackedXYAreaRenderer2(
ValueSource valueSource, PlotInstance plotInstance, boolean b) {
FormattedStackedXYAreaRenderer2 renderer = new FormattedStackedXYAreaRenderer2();
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
configureXYAreaRenderer2(valueSourceData, renderer);
initFormatDelegate(valueSource, renderer, plotInstance);
return renderer;
}
private static void initFormatDelegate(
ValueSource valueSource,
List<Integer> seriesIndices,
FormattedRenderer formattedRenderer,
PlotInstance plotInstance) {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
RenderFormatDelegate formatDelegate = formattedRenderer.getFormatDelegate();
formatDelegate.setConfiguration(valueSourceData, plotInstance);
}
private static void configureXYLineAndShapeRenderer(
XYLineAndShapeRenderer renderer, ValueSource valueSource, PlotInstance plotInstance) {
renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
SeriesFormat seriesFormat = valueSource.getSeriesFormat();
DimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfig colorDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.COLOR);
DimensionConfig shapeDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.SHAPE);
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
int seriesCount = valueSourceData.getSeriesDataForAllGroupCells().groupCellCount();
// Loop all series and set series format.
// Format based on dimension configs will be set later on in initFormatDelegate().
for (int seriesIdx = 0; seriesIdx < seriesCount; ++seriesIdx) {
// configure linestyle
if (seriesFormat.getLineStyle() == LineStyle.NONE) {
renderer.setSeriesLinesVisible(seriesIdx, false);
} else {
renderer.setSeriesLinesVisible(seriesIdx, true);
renderer.setSeriesStroke(seriesIdx, seriesFormat.getStroke(), false);
}
// configure series shape if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, shapeDimensionConfig)) {
if (seriesFormat.getItemShape() != ItemShape.NONE) {
renderer.setSeriesShapesVisible(seriesIdx, true);
renderer.setSeriesShape(seriesIdx, seriesFormat.getItemShape().getShape());
} else {
renderer.setSeriesShapesVisible(seriesIdx, false);
}
}
// configure series color if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, colorDimensionConfig)) {
Color itemColor = seriesFormat.getItemColor();
renderer.setSeriesPaint(seriesIdx, itemColor);
renderer.setSeriesFillPaint(seriesIdx, itemColor);
}
renderer.setSeriesOutlinePaint(seriesIdx, PlotConfiguration.DEFAULT_SERIES_OUTLINE_PAINT);
renderer.setUseOutlinePaint(true);
}
}
private static void configureLineAndShapeRenderer(
LineAndShapeRenderer renderer, ValueSource valueSource, PlotInstance plotInstance) {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
int seriesCount = valueSourceData.getSeriesCount();
SeriesFormat seriesFormat = valueSource.getSeriesFormat();
DimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfig colorDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.COLOR);
DimensionConfig shapeDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.SHAPE);
renderer.setDefaultEntityRadius(4);
// loop all series and set series format
for (int seriesIdx = 0; seriesIdx < seriesCount; ++seriesIdx) {
// configure linestyle
if (seriesFormat.getLineStyle() != LineStyle.NONE) {
renderer.setSeriesLinesVisible(seriesIdx, true);
renderer.setSeriesStroke(seriesIdx, seriesFormat.getStroke(), false);
} else {
renderer.setSeriesLinesVisible(seriesIdx, false);
}
// configure series shape if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, shapeDimensionConfig)) {
if (seriesFormat.getItemShape() != ItemShape.NONE) {
renderer.setSeriesShapesVisible(seriesIdx, true);
renderer.setSeriesShape(seriesIdx, seriesFormat.getItemShape().getShape());
} else {
renderer.setSeriesShapesVisible(seriesIdx, false);
}
}
// configure series color if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, colorDimensionConfig)) {
Color itemColor = seriesFormat.getItemColor();
renderer.setSeriesPaint(seriesIdx, itemColor);
}
renderer.setSeriesOutlinePaint(seriesIdx, PlotConfiguration.DEFAULT_SERIES_OUTLINE_PAINT);
renderer.setUseOutlinePaint(true);
}
}
public static XYDataset createDefaultXYDataset(ValueSource valueSource, PlotInstance plotInstace)
throws ChartPlottimeException {
DefaultXYDataset dataset = new DefaultXYDataset();
ValueSourceData valueSourceData = plotInstace.getPlotData().getValueSourceData(valueSource);
// assertMaxValueCountNotExceededOrThrowException(valueSourceData);
for (int seriesIdx = 0; seriesIdx < valueSourceData.getSeriesCount(); ++seriesIdx) {
addSeriesToDefaultXYDataset(valueSource, seriesIdx, plotInstace, dataset);
}
return dataset;
}
private static void configureAreaRenderer(
AreaRenderer renderer, ValueSource valueSource, PlotInstance plotInstance) {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
int seriesCount = valueSourceData.getSeriesCount();
SeriesFormat seriesFormat = valueSource.getSeriesFormat();
// Loop all series and set series format.
// Format based on dimension configs will be set later on in initFormatDelegate().
for (int seriesIdx = 0; seriesIdx < seriesCount; ++seriesIdx) {
renderer.setSeriesPaint(seriesIdx, seriesFormat.getAreaFillPaint());
}
}
private static void configureScatterRenderer(
ScatterRenderer renderer, ValueSource valueSource, PlotInstance plotInstance)
throws ChartPlottimeException {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
int seriesCount = valueSourceData.getSeriesCount();
SeriesFormat seriesFormat = valueSource.getSeriesFormat();
DimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfig colorDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.COLOR);
DimensionConfig shapeDimensionConfig =
plotInstance.getCurrentPlotConfigurationClone().getDimensionConfig(PlotDimension.SHAPE);
renderer.setDefaultEntityRadius(4);
// loop all series and set series format
for (int seriesIdx = 0; seriesIdx < seriesCount; ++seriesIdx) {
// lines are not supported in a ScatterRenderer, but this is already checked in
// JFreeChartPlotEngine.getWarnings().
// configure series shape if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, shapeDimensionConfig)) {
// if(seriesFormat.getItemShape() != ItemShape.NONE) {
renderer.setSeriesShape(seriesIdx, seriesFormat.getItemShape().getShape());
// } else {
// throw new ChartPlottimeException("unsupported_item_shape", valueSource.toString(),
// seriesFormat.getItemShape());
// }
}
// configure series color if necessary
if (!SeriesFormat.calculateIndividualFormatForEachItem(domainConfig, colorDimensionConfig)) {
Color itemColor = seriesFormat.getItemColor();
renderer.setSeriesPaint(seriesIdx, itemColor);
}
renderer.setSeriesOutlinePaint(seriesIdx, PlotConfiguration.DEFAULT_SERIES_OUTLINE_PAINT);
renderer.setUseOutlinePaint(true);
renderer.setDrawOutlines(true);
renderer.setUseSeriesOffset(false);
}
}
/**
* Creates the headings for the dimension config items ( like "Color (attribute X)" ) and adds it
* to legendItemCollection.
*/
private void createDimensionTitleLegendItem(
PlotInstance plotInstance,
Set<PlotDimension> dimensionSet,
LegendItemCollection legendItemCollection) {
PlotConfiguration plotConfig = plotInstance.getCurrentPlotConfigurationClone();
StringBuilder titleBuilder = new StringBuilder();
boolean first = true;
boolean showDimensionType = plotConfig.getLegendConfiguration().isShowDimensionType();
if (showDimensionType) {
for (PlotDimension dimension : dimensionSet) {
if (!first) {
titleBuilder.append(", ");
}
titleBuilder.append(dimension.getShortName());
first = false;
}
}
if (showDimensionType) {
titleBuilder.append(" (");
}
// get unique dimension labels:
Set<String> uniqueDimensionLabels = new HashSet<String>();
first = true;
for (PlotDimension dimension : dimensionSet) {
DefaultDimensionConfig dimensionConfig =
(DefaultDimensionConfig) plotConfig.getDimensionConfig(dimension);
String label = dimensionConfig.getLabel();
if (label == null) {
label = I18N.getGUILabel("plotter.unnamed_value_label");
}
if (!uniqueDimensionLabels.contains(label)) {
if (!first) {
titleBuilder.append(", ");
first = false;
}
titleBuilder.append(label);
uniqueDimensionLabels.add(label);
}
}
if (showDimensionType) {
titleBuilder.append(")");
}
titleBuilder.append(": ");
legendItemCollection.add(createTitleLegendItem(titleBuilder.toString(), plotConfig));
}
private static void initFormatDelegate(
ValueSource valueSource, FormattedRenderer formattedRenderer, PlotInstance plotInstance) {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
List<Integer> seriesIndices = new LinkedList<Integer>();
if (valueSourceData != null) {
for (int i = 0; i < valueSourceData.getSeriesCount(); ++i) {
seriesIndices.add(i);
}
} else {
LogService.getRoot()
.log(
Level.WARNING,
"com.rapidminer.gui.new_plotter.engine.jfreechart.ChartRendererFactory.null_value_source");
}
initFormatDelegate(valueSource, seriesIndices, formattedRenderer, plotInstance);
}
public LegendItemCollection getLegendItems(PlotInstance plotInstance) {
PlotConfiguration plotConfiguration = plotInstance.getCurrentPlotConfigurationClone();
LegendItemCollection legendItemCollection = new LegendItemCollection();
// Get list of ValueSources which get an own legend entry.
// These are those ValueSources, for which useSeriesFormatForDimension() returns true
// for at least one dimension (not considering X and VALUE).
// get all values sources
List<ValueSource> allValueSources = plotConfiguration.getAllValueSources();
// add the plots heading (if we have any value sources)
if (!allValueSources.isEmpty()) {
legendItemCollection.add(
createTitleLegendItem(
I18N.getGUILabel("plotter.legend.plots_heading.label") + ":", plotConfiguration));
}
// now find those value sources for which we need a legend entry,
// and also remember which dimensions are shown in the legend entry (color, shape, ...)
for (ValueSource valueSource : allValueSources) {
CustomLegendItem legendItem = createValueSourceLegendItem(plotConfiguration, valueSource);
if (legendItem != null) {
legendItemCollection.add(legendItem);
}
}
List<Set<PlotDimension>> dimensionsWithLegend =
findCompatibleDimensions(plotConfiguration, allValueSources);
// create legend items for DimensionConfigs
for (Set<PlotDimension> dimensionSet : dimensionsWithLegend) {
PlotDimension aDimension = dimensionSet.iterator().next();
DimensionConfig dimensionConfig = plotConfiguration.getDimensionConfig(aDimension);
createDimensionConfigLegendItem(
plotInstance,
(DefaultDimensionConfig) dimensionConfig,
dimensionSet,
legendItemCollection);
}
return legendItemCollection;
}
/**
* Creates a continuous legend item for one item in dimensionSet, i.e. dimensionSet must be a set
* containing exactly one value.
*
* @param dateFormat format used to format minValue and maxValue as dates, or null if they should
* be displayed numerically instead of as dates
* @throws ChartPlottimeException
*/
private LegendItem createContinuousLegendItem(
PlotInstance plotInstance,
Set<PlotDimension> dimensionSet,
double minValue,
double maxValue,
DateFormat dateFormat) {
PlotConfiguration plotConfiguration = plotInstance.getCurrentPlotConfigurationClone();
PlotDimension dimension = dimensionSet.iterator().next();
DefaultDimensionConfig dimensionConfig =
(DefaultDimensionConfig) plotConfiguration.getDimensionConfig(dimension);
DimensionConfigData dimensionConfigData =
plotInstance.getPlotData().getDimensionConfigData(dimensionConfig);
// String label = dimensionConfig.getLabel();
// if(label == null) {
// label = I18N.getGUILabel("plotter.unnamed_value_label");
// }
String label = "";
if (dimension == PlotDimension.COLOR) {
ColorProvider colorProvider = dimensionConfigData.getColorProvider();
if (!colorProvider.supportsNumericalValues()) {
throw new RuntimeException(
"Color provider for continuous legend item does not support numerical values.");
}
// shape dimensions
final int width = 50;
final int height = 10;
// create item paint
// first disable logarithmic scale on color provider ( -> linear gradient in legend)
// ContinuousColorProvider continuousColorProvider = null;
// if (dimensionConfig.isLogarithmic() && colorProvider instanceof
// ContinuousColorProvider) {
// continuousColorProvider = (ContinuousColorProvider)colorProvider;
// continuousColorProvider.setLogarithmic(false);
// }
// calculate gradient
float fractions[] = new float[width];
Color colors[] = new Color[width];
for (int i = 0; i < width; ++i) {
float fraction = i / (width - 1.0f);
double fractionValue;
if (colorProvider instanceof ContinuousColorProvider
&& ((ContinuousColorProvider) colorProvider)
.isColorMinMaxValueDifferentFromOriginal(
((ContinuousColorProvider) colorProvider).getMinValue(),
((ContinuousColorProvider) colorProvider).getMaxValue())) {
fractionValue =
((ContinuousColorProvider) colorProvider).getMinValue()
+ fraction
* (((ContinuousColorProvider) colorProvider).getMaxValue()
- ((ContinuousColorProvider) colorProvider).getMinValue());
} else {
fractionValue = minValue + fraction * (maxValue - minValue);
}
colors[i] = colorProvider.getColorForValue(fractionValue);
fractions[i] = fraction;
}
LinearGradientPaint shapeFillPaint =
new LinearGradientPaint(
new Point(0, 0), new Point(width, 0), fractions, colors, CycleMethod.REPEAT);
// reset color provider to logarithmic if necessary
// if (continuousColorProvider != null && dimensionConfig.isLogarithmic()) {
// continuousColorProvider.setLogarithmic(true);
// }
// create item shape
Rectangle itemShape = new Rectangle(width, height);
if (colorProvider instanceof ContinuousColorProvider) {
return createFlankedShapeLegendItem(
label,
((ContinuousColorProvider) colorProvider).getMinValue(),
((ContinuousColorProvider) colorProvider).getMaxValue(),
itemShape,
shapeFillPaint,
true,
dateFormat);
} else {
return createFlankedShapeLegendItem(
label, minValue, maxValue, itemShape, shapeFillPaint, true, dateFormat);
}
} else if (dimension == PlotDimension.SHAPE) {
// shape provider probably never supports numerical values
return null;
} else if (dimension == PlotDimension.SIZE) {
SizeProvider sizeProvider = dimensionConfigData.getSizeProvider();
if (!sizeProvider.supportsNumericalValues()) {
throw new RuntimeException(
"Size provider for continuous legend item does not support numerical values.");
}
double minScalingFactor = sizeProvider.getMinScalingFactor();
double maxScalingFactor = sizeProvider.getMaxScalingFactor();
ContinuousSizeProvider legendSizeProvider =
new ContinuousSizeProvider(
minScalingFactor,
maxScalingFactor,
MIN_LEGEND_ITEM_SCALING_FACTOR,
MAX_LEGEND_ITEM_SCALING_FACTOR,
false);
int legendItemCount = 4;
Area composedShape = new Area();
Shape originalShape = UNDEFINED_SHAPE;
if (dimensionSet.contains(PlotDimension.SIZE) && dimensionSet.size() == 1) {
originalShape = UNDEFINED_SHAPE_AND_COLOR;
}
double maxHeight = originalShape.getBounds().getHeight() * MAX_LEGEND_ITEM_SCALING_FACTOR;
for (int i = 0; i < legendItemCount; ++i) {
double fraction =
minScalingFactor
+ ((double) i / legendItemCount * (maxScalingFactor - minScalingFactor));
double legendScalingFactor = legendSizeProvider.getScalingFactorForValue(fraction);
double composedWidth = composedShape.getBounds().getWidth();
AffineTransform t = new AffineTransform();
t.scale(legendScalingFactor, legendScalingFactor);
Shape shape = t.createTransformedShape(originalShape);
t = new AffineTransform();
double shapeWidth = shape.getBounds().getWidth();
double shapeHeight = shape.getBounds().getHeight();
t.translate(composedWidth + shapeWidth * .1, (maxHeight - shapeHeight) / 2.0);
t.translate(-shape.getBounds().getMinX(), -shape.getBounds().getMinY());
shape = t.createTransformedShape(shape);
composedShape.add(new Area(shape));
}
return createFlankedShapeLegendItem(
label, minValue, maxValue, composedShape, UNDEFINED_COLOR_PAINT, false, dateFormat);
} else {
throw new RuntimeException(
"Unsupported dimension. Execution path should never reach this line.");
}
}
private void createDimensionConfigLegendItem(
PlotInstance plotInstance,
DefaultDimensionConfig dimensionConfig,
Set<PlotDimension> dimensionSet,
LegendItemCollection legendItemCollection) {
PlotConfiguration plotConfiguration = plotInstance.getCurrentPlotConfigurationClone();
DimensionConfigData dimensionConfigData =
plotInstance.getPlotData().getDimensionConfigData(dimensionConfig);
if (dimensionConfig.isGrouping()) {
// create legend entry based on the grouping
if (dimensionConfig.isNominal()) {
// create categorical legend --> one item for each category
createCategoricalLegendItems(
plotInstance,
dimensionSet,
legendItemCollection,
dimensionConfigData.getDistinctValues());
} else if (dimensionConfig.isNumerical() || dimensionConfig.isDate()) {
createDimensionTitleLegendItem(plotInstance, dimensionSet, legendItemCollection);
// create one continuous legend item
double minValue = dimensionConfigData.getMinValue();
double maxValue = dimensionConfigData.getMaxValue();
LegendItem legendItem =
createContinuousLegendItem(
plotInstance,
dimensionSet,
minValue,
maxValue,
dimensionConfig.isDate() ? dimensionConfig.getDateFormat() : null);
if (legendItem != null) {
legendItemCollection.add(legendItem);
}
} else {
throw new RuntimeException(
"unknown data type during legend creation - this should not happen");
}
} else {
// dimension config not grouping --> create legend item only, if there exists
// at least one non-aggregated value source (otherwise the dimension config is
// not used at all in the plot and thus we also don't need a legend item for it).
boolean createLegend = false;
for (ValueSource valueSource : plotConfiguration.getAllValueSources()) {
if (!valueSource.isUsingDomainGrouping()) {
createLegend = true;
break;
}
}
if (createLegend) {
// create legend based on the attribute values on the dimension config
if (dimensionConfig.isNominal()) {
// create one legend item for each nominal value
List<Double> values = dimensionConfigData.getDistinctValues();
createCategoricalLegendItems(plotInstance, dimensionSet, legendItemCollection, values);
} else if (dimensionConfig.isNumerical() || dimensionConfig.isDate()) {
createDimensionTitleLegendItem(plotInstance, dimensionSet, legendItemCollection);
// create one continuous legend item for the value range
double minValue = dimensionConfigData.getMinValue();
double maxValue = dimensionConfigData.getMaxValue();
LegendItem legendItem =
createContinuousLegendItem(
plotInstance,
dimensionSet,
minValue,
maxValue,
dimensionConfig.isDate() ? dimensionConfig.getDateFormat() : null);
if (legendItem != null) {
legendItemCollection.add(legendItem);
}
} else {
throw new RuntimeException(
"unknown data type during legend creation - this should not happen");
}
}
}
}
/**
* Creates a dataset which supports custom intervals on both axes.
*
* <p>Expects a grouping on the domain axis.
*
* @throws ChartPlottimeException
*/
public static DefaultIntervalXYDataset createDefaultIntervalXYDataset(
ValueSource valueSource, PlotInstance plotInstance, boolean createRangeIntervals)
throws ChartPlottimeException {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
DefaultIntervalXYDataset intervalDataset = new DefaultIntervalXYDataset();
DefaultDimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfigData domainConfigData =
plotInstance.getPlotData().getDimensionConfigData(domainConfig);
// Loop all group cells and add data to dataset
for (GroupCellKeyAndData groupCellKeyAndData : dataForAllGroupCells) {
GroupCellKey groupCellKey = groupCellKeyAndData.getKey();
GroupCellData groupCellData = groupCellKeyAndData.getData();
// create series name
GroupCellKey groupCellKeyClone = (GroupCellKey) groupCellKey.clone();
groupCellKeyClone.removeRangeForDimension(
PlotDimension.DOMAIN); // legend does not need X-group
String seriesName =
generateSeriesName(
valueSource, groupCellKeyClone, plotInstance.getCurrentPlotConfigurationClone());
List<ValueRange> domainValueGroups = domainConfigData.getGroupingModel();
// Loop all rows and add data to series.
// Remember that by definition one row in the groupCellData corresponds
// to one group in xValueGroups (if the x-axis is grouped, which should
// always be the case in this function).
final int domainValueIdx = 0;
final int domainLowerIdx = 1;
final int domainUpperIdx = 2;
final int rangeValueIdx = 3;
final int rangeLowerIdx = 4;
final int rangeUpperIdx = 5;
Map<PlotDimension, double[]> dataForMainSeries =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
int rowCount = dataForMainSeries.get(PlotDimension.DOMAIN).length;
double[] domainValues = dataForMainSeries.get(PlotDimension.DOMAIN);
double[] rangeValues = dataForMainSeries.get(PlotDimension.VALUE);
double[] upperErrorValues = null;
double[] lowerErrorValues = null;
upperErrorValues = valueSourceData.getAbsoluteUtilityValues(groupCellKeyAndData, true);
lowerErrorValues = valueSourceData.getAbsoluteUtilityValues(groupCellKeyAndData, false);
if (createRangeIntervals && upperErrorValues == null) {
throw new ChartPlottimeException(
"undefined_series", valueSource.toString(), SeriesUsageType.INDICATOR_1);
}
double[][] series = new double[6][rowCount];
Iterator<ValueRange> domainGroupIterator = null;
if (domainValueGroups != null) {
domainGroupIterator = domainValueGroups.iterator();
}
double domainLower;
double domainUpper;
double domainValue;
double rangeValue;
double rangeUpper;
double rangeLower;
for (int row = 0; row < rowCount; ++row) {
domainValue = domainValues[row];
domainLower = domainValue;
domainUpper = domainValue;
if (domainGroupIterator != null) {
ValueRange currentDomainGroup = domainGroupIterator.next();
if (currentDomainGroup.definesUpperLowerBound()) {
domainLower = currentDomainGroup.getLowerBound();
domainUpper = currentDomainGroup.getUpperBound();
}
}
rangeValue = rangeValues[row];
rangeUpper = upperErrorValues != null ? upperErrorValues[row] : Double.NaN;
rangeLower = lowerErrorValues != null ? lowerErrorValues[row] : Double.NaN;
series[domainValueIdx][row] = domainValue;
series[domainLowerIdx][row] = domainLower;
series[domainUpperIdx][row] = domainUpper;
series[rangeValueIdx][row] = rangeValue;
series[rangeLowerIdx][row] = rangeLower;
series[rangeUpperIdx][row] = rangeUpper;
}
intervalDataset.addSeries(seriesName, series);
}
return intervalDataset;
}
private void createCategoricalLegendItems(
PlotInstance plotInstance,
Set<PlotDimension> dimensionSet,
LegendItemCollection legendItemCollection,
Iterable<Double> values) {
createDimensionTitleLegendItem(plotInstance, dimensionSet, legendItemCollection);
PlotConfiguration plotConfig = plotInstance.getCurrentPlotConfigurationClone();
Shape defaultShape = new Ellipse2D.Float(-5f, -5f, 10f, 10f);
Color defaultOutlineColor = PlotConfiguration.DEFAULT_OUTLINE_COLOR;
ColorProvider colorProvider = null;
ShapeProvider shapeProvider = null;
SizeProvider sizeProvider = null;
DefaultDimensionConfig dimensionConfig =
(DefaultDimensionConfig) plotConfig.getDimensionConfig(dimensionSet.iterator().next());
DimensionConfigData dimensionConfigData =
plotInstance.getPlotData().getDimensionConfigData(dimensionConfig);
for (PlotDimension dimension : dimensionSet) {
if (dimension == PlotDimension.COLOR) {
colorProvider = dimensionConfigData.getColorProvider();
} else if (dimension == PlotDimension.SHAPE) {
shapeProvider = dimensionConfigData.getShapeProvider();
} else if (dimension == PlotDimension.SIZE) {
sizeProvider = dimensionConfigData.getSizeProvider();
}
}
// initialize size scale for legend
ContinuousSizeProvider legendSizeProvider = null;
if (sizeProvider != null) {
double minScalingFactor = sizeProvider.getMinScalingFactor();
double maxScalingFactor = sizeProvider.getMaxScalingFactor();
double minLegendScalingFactor = MIN_LEGEND_ITEM_SCALING_FACTOR;
double maxLegendScalingFactor = MAX_LEGEND_ITEM_SCALING_FACTOR;
if (minScalingFactor > maxScalingFactor) {
double tmp = minScalingFactor;
minScalingFactor = maxScalingFactor;
maxScalingFactor = tmp;
minLegendScalingFactor = MAX_LEGEND_ITEM_SCALING_FACTOR;
maxLegendScalingFactor = MIN_LEGEND_ITEM_SCALING_FACTOR;
}
legendSizeProvider =
new ContinuousSizeProvider(
minScalingFactor,
maxScalingFactor,
minLegendScalingFactor,
maxLegendScalingFactor,
false);
}
for (Double value : values) {
// configure shape and stroke
Shape shape = defaultShape;
BasicStroke outlineStroke;
Color outlineColor = new Color(0, 0, 0, 0);
if (shapeProvider != null) {
shape = shapeProvider.getShapeForCategory(value);
outlineStroke = DEFAULT_OUTLINE_STROKE;
outlineColor = defaultOutlineColor;
} else {
outlineStroke = new BasicStroke();
if (colorProvider != null) {
shape = UNDEFINED_SHAPE;
} else {
shape = UNDEFINED_SHAPE_AND_COLOR;
}
}
// configure fill paint
Paint paint = UNDEFINED_COLOR_PAINT;
if (colorProvider != null) {
paint = colorProvider.getColorForValue(value);
}
double scalingFactor = 1;
if (sizeProvider != null) {
// scale shape according to sizeProvider
scalingFactor = sizeProvider.getScalingFactorForValue(value);
// scale shape to fit into legend
scalingFactor = legendSizeProvider.getScalingFactorForValue(scalingFactor);
AffineTransform transformation = new AffineTransform();
transformation.scale(scalingFactor, scalingFactor);
shape = transformation.createTransformedShape(shape);
}
String label = dimensionConfigData.getStringForValue(value);
if (label == null) {
label = "";
}
CustomLegendItem legendItem =
new CustomLegendItem(label, null, null, null, shape, paint, outlineStroke, outlineColor);
legendItemCollection.add(legendItem);
}
}
public static CategoryDataset createDefaultCategoryDataset(
ValueSource valueSource,
PlotInstance plotInstance,
boolean fillWithZero,
boolean allowValuesLessThanZero)
throws ChartPlottimeException {
ValueSourceData valueSourceData = plotInstance.getPlotData().getValueSourceData(valueSource);
assertMaxValueCountNotExceededOrThrowException(valueSourceData);
GroupCellSeriesData dataForAllGroupCells = valueSourceData.getSeriesDataForAllGroupCells();
DefaultDimensionConfig domainConfig = valueSource.getDomainConfig();
DimensionConfigData domainConfigData =
plotInstance.getPlotData().getDimensionConfigData(domainConfig);
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for (GroupCellKeyAndData groupCellKeyAndData : dataForAllGroupCells) {
GroupCellKey groupCellKey = groupCellKeyAndData.getKey();
GroupCellData groupCellData = groupCellKeyAndData.getData();
// create series name
GroupCellKey groupCellKeyClone = (GroupCellKey) groupCellKey.clone();
String seriesName =
generateSeriesName(
valueSource, groupCellKeyClone, plotInstance.getCurrentPlotConfigurationClone());
Map<PlotDimension, double[]> dataForUsageType =
groupCellData.getDataForUsageType(SeriesUsageType.MAIN_SERIES);
double[] xValues = dataForUsageType.get(PlotDimension.DOMAIN);
double[] yValues = dataForUsageType.get(PlotDimension.VALUE);
int rowCount = xValues.length;
for (int row = 0; row < rowCount; ++row) {
double xValue = xValues[row];
String xString = null;
xString = domainConfigData.getStringForValue(xValue);
Double y = yValues[row];
if (!allowValuesLessThanZero && y < 0) {
throw new ChartPlottimeException("illegal_zero_value", valueSource.toString());
}
if (xString != null) {
dataset.addValue(y, seriesName, xString);
}
}
if (fillWithZero) {
for (int row = 0; row < rowCount; ++row) {
double xValue = xValues[row];
String xString = null;
xString = domainConfigData.getStringForValue(xValue);
Number value = dataset.getValue(seriesName, xString);
if (value == null || Double.isNaN(value.doubleValue())) {
dataset.addValue(0, seriesName, xString);
}
}
}
}
return dataset;
}
