Changeset 2128 for trunk

Timestamp:

08/24/16 09:58:25 (8 years ago)

Author:

pharms

Message:

• replaced uninterpretable event coverage plot with a more interpretable

File:

• trunk/autoquest-ui-swt/src/main/java/de/ugoe/cs/autoquest/ui/swt/TaskTreePlotUtils.java (modified) (5 diffs)

trunk/autoquest-ui-swt/src/main/java/de/ugoe/cs/autoquest/ui/swt/TaskTreePlotUtils.java

@@ -28 +28 @@
 import java.util.Map;
 import java.util.Set;
-import java.util.TreeMap;
 
 import org.jfree.chart.ChartFactory;
@@ -57 +56 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInfo;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.TaskMetric;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.TaskTreeUtils;
 
@@ -101 +98 @@
         
         if (TASK_COUNT__EVENT_COVERAGE_PLOT.equals(name)) {
-            XYDataset dataset1 = createTaskCountEventCoveragePlotDataSet(models.get(0));
+            XYDataset dataset1 = createTaskCountEventCoveragePlotDataSet(models.get(0),
+                                                                         modelNames.get(0));
             
             chart = ChartFactory.createXYLineChart
-                (TASK_COUNT__EVENT_COVERAGE_PLOT, "task counts", "event coverage",
+                (TASK_COUNT__EVENT_COVERAGE_PLOT, "Sequences ordered by coverage in % of sequences",
+                 "action instances in % of all recorded action instances covered by the sequence",
                  dataset1, PlotOrientation.VERTICAL, models.size() > 1, false, false);
             
             for (int i = 1; i < models.size(); i++) {
                 chart.getXYPlot().setDataset
-                    (i, createTaskCountEventCoveragePlotDataSet(models.get(i)));
+                    (i, createTaskCountEventCoveragePlotDataSet(models.get(i),
+                                                                modelNames.get(i)));
             }
             
             XYPlot plot = chart.getXYPlot();
-            NumberAxis domainAxis = new LogarithmicAxis("task counts");
-            NumberAxis rangeAxis = new LogarithmicAxis("event coverage");
+            plot.setBackgroundPaint(java.awt.Color.WHITE);
+            plot.setDomainAxisLocation(AxisLocation.BOTTOM_OR_RIGHT);
+
+            XYLineAndShapeRenderer scatterRenderer = new XYLineAndShapeRenderer(false, true);
+            scatterRenderer.setSeriesShapesFilled(0, false);
+            scatterRenderer.setSeriesShape(0, new Ellipse2D.Float(-3.0f, -3.0f, 6.0f, 6.0f));
+            scatterRenderer.setSeriesPaint(0, colors[0]);
+            plot.setRenderer(0, scatterRenderer);
+
+            for (int i = 1; i < models.size(); i++) {
+                chart.getXYPlot().setDataset
+                    (i, createOrderedTaskCountPlotDataSet(models.get(i), modelNames.get(i)));
+                
+                scatterRenderer = new XYLineAndShapeRenderer(false, true);
+                scatterRenderer.setSeriesShapesFilled(0, false);
+                scatterRenderer.setSeriesShape(0, new Ellipse2D.Float(-3.0f, -3.0f, 6.0f, 6.0f));
+                scatterRenderer.setSeriesPaint(0, colors[i]);
+                plot.setRenderer(i, scatterRenderer);
+            }
+
+            NumberAxis domainAxis = new NumberAxis
+                ("Sequences ordered by coverage in % of sequences");
+            
+            domainAxis.setUpperBound(100);
             plot.setDomainAxis(domainAxis);
+            
+            NumberAxis rangeAxis = new LogarithmicAxis
+                ("action instances in % of all recorded action instances covered by the sequence");
+            
+            rangeAxis.setAutoRange(true);
             plot.setRangeAxis(rangeAxis);
         }
@@ -285 +312 @@
      *
      */
-    private static XYDataset createTaskCountEventCoveragePlotDataSet(ITaskModel taskModel) {
-        // tree maps required to have sorted maps
-        TreeMap<Integer, Integer> minValues = new TreeMap<>();
-        TreeMap<Integer, List<Integer>> allValues = new TreeMap<>();
-        TreeMap<Integer, Integer> maxValues = new TreeMap<>();
+    private static XYDataset createTaskCountEventCoveragePlotDataSet(ITaskModel taskModel,
+                                                                     String     taskModelName)
+    {
+        Map<Integer, List<ISequence>> coverageCounts = new HashMap<>();
+        Map<ISequence, Set<IEventTaskInstance>> coverages = new HashMap<>();
+        Set<IEventTaskInstance> allEvents = new HashSet<>();
+        int maxCoverage = 0;
         
         for (ITask task : taskModel.getTasks()) {
             if (task instanceof ISequence) {
-                ITaskInfo info = taskModel.getTaskInfo(task);
-                int count = task.getInstances().size();
-                int eventCoverage = info.getMeasureValue(TaskMetric.EVENT_COVERAGE);
-
-                Integer minValue = minValues.get(count);
-
-                if ((minValue == null) || (minValue > eventCoverage)) {
-                    minValues.put(count, eventCoverage);
-                }
-
-                Integer maxValue = maxValues.get(count);
-
-                if ((maxValue == null) || (maxValue < eventCoverage)) {
-                    maxValues.put(count, eventCoverage);
-                }
-
-                List<Integer> values = allValues.get(count);
-
-                if (values == null) {
-                    values = new LinkedList<Integer>();
-                    allValues.put(count, values);
-                }
-
-                values.add(eventCoverage);
+                final Set<IEventTaskInstance> coveredEvents = new HashSet<>();
+                
+                for (ITaskInstance instance : task.getInstances()) {
+                    instance.accept(new DefaultTaskInstanceTraversingVisitor() {
+                        @Override
+                        public void visit(IEventTaskInstance eventTaskInstance) {
+                            coveredEvents.add(eventTaskInstance);
+                        }
+                    });
+                }
+                
+                coverages.put((ISequence) task, coveredEvents);
+                
+                List<ISequence> tasksWithSameCoverage = coverageCounts.get(coveredEvents.size());
+
+                if (tasksWithSameCoverage == null) {
+                    tasksWithSameCoverage = new LinkedList<>();
+                    coverageCounts.put(coveredEvents.size(), tasksWithSameCoverage);
+                }
+
+                tasksWithSameCoverage.add((ISequence) task);
+                
+                maxCoverage = Math.max(maxCoverage, coveredEvents.size());
+            }
+            else if (task instanceof IEventTask) {
+                for (ITaskInstance instance : task.getInstances()) {
+                    allEvents.add((IEventTaskInstance) instance);
+                }
+            }
+        }
+        
+        XYSeries countSeries = new XYSeries(taskModelName, true, false);
+        
+        // entries are correctly sorted due to the map
+        int sequenceIndex = 1;
+        
+        for (int i = maxCoverage; i > 0; i--) {
+            List<ISequence> sequencesWithSameCoverage = coverageCounts.get(i);
+
+            if (sequencesWithSameCoverage == null) {
+                continue;
+            }
+            
+            for (ISequence sequence : sequencesWithSameCoverage) {
+                double xvalue = (double) 100 * sequenceIndex / coverages.size();
+                double yvalue = (double) 100 * coverages.get(sequence).size() / allEvents.size();
+                countSeries.add(xvalue, yvalue);
+                sequenceIndex++;
             }
         }
         
         DefaultTableXYDataset dataset = new DefaultTableXYDataset();
-        XYSeries minSeries = new XYSeries("min values", true, false);
-        XYSeries avgSeries = new XYSeries("avg values", true, false);
-        XYSeries maxSeries = new XYSeries("max values", true, false);
-        
-        // entries are correctly sorted due to the map
-        for (Map.Entry<Integer, List<Integer>> entry : allValues.entrySet()) {
-            int count = entry.getKey();
-
-            minSeries.add(count, minValues.get(count));
-            maxSeries.add(count, maxValues.get(count));
-            
-            avgSeries.add(count, getAverage(entry.getValue()));
-        }
-        
-        dataset.addSeries(minSeries);
-        dataset.addSeries(avgSeries);
-        dataset.addSeries(maxSeries);
+        dataset.addSeries(countSeries);
         return dataset;
     }
@@ -474 +511 @@
     }
 
-
-    /**
-     *
-     */
-    private static double getAverage(List<Integer> values) {
-        int all = 0;
-        
-        for (Integer value : values) {
-            all += value;
-        }
-
-        return ((double) all) / values.size();
-    }
 }