Statistics
| Revision:

svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.library / org.gvsig.expressionevaluator / org.gvsig.expressionevaluator.lib / org.gvsig.expressionevaluator.lib.impl / src / main / java / org / gvsig / expressionevaluator / impl / function / programming / CreateChartPanelFunction.java @ 46104

History | View | Annotate | Download (6.4 KB)

1
package org.gvsig.expressionevaluator.impl.function.programming;
2

    
3
import java.awt.Dimension;
4
import java.util.ArrayList;
5
import java.util.HashMap;
6
import java.util.Iterator;
7
import java.util.List;
8
import java.util.Objects;
9
import javax.json.JsonArray;
10
import javax.json.JsonObject;
11
import javax.json.JsonValue;
12
import org.apache.commons.lang3.Range;
13
import org.apache.commons.lang3.StringUtils;
14
import org.apache.commons.lang3.math.NumberUtils;
15
import org.gvsig.expressionevaluator.ExpressionRuntimeException;
16
import org.gvsig.expressionevaluator.Function;
17
import org.gvsig.expressionevaluator.Interpreter;
18
import org.gvsig.expressionevaluator.spi.AbstractFunction;
19
import org.gvsig.expressionevaluator.spi.JsonUtils;
20
import org.gvsig.tools.util.GetItemByKey;
21
import org.gvsig.tools.util.GetItemWithSize;
22
import org.jfree.chart.ChartFactory;
23
import org.jfree.chart.ChartPanel;
24
import org.jfree.chart.JFreeChart;
25
import org.jfree.chart.plot.PlotOrientation;
26
import org.jfree.data.category.DefaultCategoryDataset;
27
import org.jfree.data.statistics.BoxAndWhiskerItem;
28
import org.jfree.data.statistics.DefaultBoxAndWhiskerCategoryDataset;
29
import org.jfree.data.statistics.DefaultBoxAndWhiskerXYDataset;
30

    
31
public class CreateChartPanelFunction extends AbstractFunction {
32

    
33
        public CreateChartPanelFunction() {
34
                super(
35
                        Function.GROUP_PROGRAMMING,
36
                        "CREATE_CHARTPANEL",
37
                        Range.between(1, 2),
38
                        "",
39
                        "CREATE_CHARTPANEL" + "({{string}})",
40
                        null,
41
                        "ChartPanel",
42
                        false
43
                );
44
        }
45

    
46
        @Override
47
        public boolean allowConstantFolding() {
48
                return false;
49
        }
50

    
51
        @Override
52
        public Object call(Interpreter interpreter, final Object[] args) throws Exception {
53
                Object obj = getObject(args, 0);
54
                if (obj == null) {
55
                        return null;
56
                        //throw new ExpressionRuntimeException("Null is not valid in "+FUNCTION_GETITEM+" function.");
57
                }
58

    
59
                if (!(obj instanceof JsonObject)) {
60
                        obj = JsonUtils.toJsonObject(obj);
61
                }
62
                
63
                Iterable dataset = null;
64
                if (args.length>0) {
65
                        Object obj1 = getObject(args, 1);
66
                        if ((obj1 instanceof GetItemWithSize)) {
67
                                GetItemWithSize values = (GetItemWithSize) obj1;
68
                                dataset = new Iterable() {
69
                                        @Override
70
                                        public Iterator iterator() {
71
                                                return new Iterator() {
72
                                                        int n = 0;
73
                                                        @Override
74
                                                        public boolean hasNext() {
75
                                                                return n < values.size();
76
                                                        }
77

    
78
                                                        @Override
79
                                                        public Object next() {
80
                                                                return values.get(n++);
81
                                                        }
82
                                                };
83
                                        }
84
                                };
85
                        } else if (obj1 instanceof Iterable) {
86
                                dataset = (Iterable) obj1;
87
                        } else {
88
                                throw new ExpressionRuntimeException("dataset type not supported");
89
                        }
90
                }
91

    
92
                JsonObject jsonobj = ((JsonObject) obj);
93
                ChartPanel graph = createGraph(jsonobj, dataset);
94
                return graph;
95

    
96
        }
97

    
98
        public ChartPanel createGraph(JsonObject json, Iterable<GetItemByKey> dataset) {
99
                String chartType = json.getString("chartType").toLowerCase();
100
                switch (chartType) {
101
                        case "boxandwhisker": {
102
                                String valueField = json.getString("valueField");
103
                                HashMap<String, HashMap<String, List<Number>>> tree = new HashMap<String, HashMap<String, List<Number>>>();
104
                                String field1 = json.getString("field1");
105
                                String field2 = json.getString("field2");
106
                                for (GetItemByKey element : dataset) {
107
                                        String rowValue = Objects.toString(element.get(field1), null);
108
                                        String colValue = Objects.toString(element.get(field2), null);
109
                                        double elementValue = NumberUtils.toDouble(Objects.toString(element.get(valueField), null));
110

    
111
                                        if (tree.containsKey(rowValue)) {
112
                                                HashMap<String, List<Number>> colTree = tree.get(rowValue);
113
                                                if (colTree.containsKey(colValue)) {
114
                                                        colTree.get(colValue).add(elementValue);
115
                                                } else {
116
                                                        ArrayList<Number> list = new ArrayList<Number>();
117
                                                        list.add(elementValue);
118
                                                        colTree.put(colValue, list);
119
                                                }
120
                                        } else {
121
                                                HashMap<String, List<Number>> e = new HashMap<String, List<Number>>();
122
                                                ArrayList<Number> list = new ArrayList<Number>();
123
                                                list.add(elementValue);
124
                                                e.put(colValue, list);
125
                                                tree.put(rowValue, e);
126
                                        }
127
                                }
128
                                DefaultBoxAndWhiskerCategoryDataset ds = new DefaultBoxAndWhiskerCategoryDataset();
129
                                for (String rowKey : tree.keySet()) {
130
                                        for (String colKey : tree.get(rowKey).keySet()) {
131
                                                ds.add(tree.get(rowKey).get(colKey), rowKey, colKey);
132
                                        }
133
                                }
134
                                try {
135

    
136
                                } catch (Exception ex) {
137
                                        throw new RuntimeException("Not able to retrieve values", ex);
138
                                }
139

    
140
                                JFreeChart boxAndWhiskerChart = ChartFactory.createBoxAndWhiskerChart(
141
                                        json.getString("title", ""),
142
                                        json.getString("categoryAxisLabel", ""),
143
                                        json.getString("valueAxisLabel", ""),
144
                                        ds,
145
                                        json.getBoolean("legend", true));
146

    
147
                                ChartPanel chartPanel = new ChartPanel(boxAndWhiskerChart);
148
                                chartPanel.setPreferredSize(new Dimension(json.getInt("witdh", 360), json.getInt("height", 200)));
149
                                return chartPanel;
150
                        }
151

    
152
                        case "barchart": {
153
                                DefaultCategoryDataset ds = new DefaultCategoryDataset();
154
                                if (dataset == null) {
155
                                        JsonArray datasetJson = json.getJsonArray("dataset");
156
                                        for (JsonValue jsonValue : datasetJson) {
157
                                                JsonArray element = (JsonArray) jsonValue;
158
                                                double value = element.getJsonNumber(0).doubleValue();
159
                                                String field1 = element.getString(1, null);
160
                                                String field2 = element.getString(2, null);
161
                                                ds.addValue(value, field1, field2);
162
                                        }
163
                                } else {
164
                                        String valueField = json.getString("valueField");
165
                                        String field1 = json.getString("field1");
166
                                        String field2 = json.getString("field2");
167
                                        for (GetItemByKey element : dataset) {
168

    
169
                                                try {
170
                                                        ds.addValue(NumberUtils.toDouble(Objects.toString(element.get(valueField), null), Double.NaN),
171
                                                                Objects.toString(element.get(field1), null),
172
                                                                Objects.toString(element.get(field2), null));
173
                                                } catch (Exception ex) {
174
                                                        throw new RuntimeException("Not able to retrieve values", ex);
175
                                                }
176
                                        }
177

    
178
                                }
179
                                JFreeChart barChart = ChartFactory.createBarChart(
180
                                        json.getString("title", ""),
181
                                        json.getString("categoryAxisLabel", ""),
182
                                        json.getString("valueAxisLabel", ""),
183
                                        ds,
184
                                        StringUtils.equalsIgnoreCase(json.getString("orientation", null), "HORIZONTAL") ? PlotOrientation.HORIZONTAL : PlotOrientation.VERTICAL,
185
                                        json.getBoolean("legend", true),
186
                                        false,
187
                                        false);
188

    
189
                                ChartPanel chartPanel = new ChartPanel(barChart);
190
                                chartPanel.setPreferredSize(new Dimension(json.getInt("witdh", 360), json.getInt("height", 200)));
191
                                return chartPanel;
192
                        }
193
                        default:
194
                                throw new IllegalArgumentException("Unknown chart type:" + chartType);
195

    
196
                }
197
        }
198

    
199
}