Changeset 2162 for trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java

Timestamp:

09/07/17 16:15:00 (7 years ago)

Author:

pharms

Message:

• changes for first VR oriented usability evaluation

File:

• trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java (modified) (8 diffs)

trunk/autoquest-core-usability/src/main/java/de/ugoe/cs/autoquest/usability/UsabilityEvaluationManager.java

@@ -17 +17 @@
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
+import java.util.Set;
 import java.util.logging.Level;
 
+import de.ugoe.cs.autoquest.tasktrees.treeifc.DefaultTaskInstanceTraversingVisitor;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IMarkingTemporalRelationship;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ISequence;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IStructuringTemporalRelationship;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
 import de.ugoe.cs.util.console.Console;
@@ -58 +64 @@
         rules.add(new TargetDistanceRule());
         rules.add(new MissingFeedbackRule());
+        rules.add(new TaskRetryRule());
         rules.add(new DataEntryMethodChangeRule());
         rules.add(new CommonTaskRateRule());
@@ -73 +80 @@
      *
      */
-    public UsabilityEvaluationResult evaluateUsability(ITaskModel taskModel, int maxCount) {
+    public UsabilityEvaluationResult evaluateUsability(ITaskModel taskModel,
+                                                       int        maxCount,
+                                                       boolean    onlyMostRepresentative)
+    {
         Console.traceln(Level.INFO, "evaluating usability of task model " + taskModel);
 
         List<UsabilityEvaluationResult> interimResults = new ArrayList<UsabilityEvaluationResult>();
+        Set<ITask> mostRepresentativeTasks = null;
 
         for (UsabilityEvaluationRule rule : rules) {
             Console.traceln(Level.INFO, "\napplying rule " + rule.getClass().getSimpleName());
-            UsabilityEvaluationResult result = rule.evaluate(taskModel);
+            UsabilityEvaluationResult ruleResult = rule.evaluate(taskModel);
 
             Map<String, List<UsabilitySmell>> smellGroups = new HashMap<>();
             
-            for (UsabilitySmell smell : result.getAllSmells()) {
+            for (UsabilitySmell smell : ruleResult.getAllSmells()) {
                 List<UsabilitySmell> smellGroup = smellGroups.get(smell.getBriefDescription());
                 
@@ -99 +110 @@
                                 " usability smells of type \"" + smellGroup.getKey() + "\"");
                 
-                result = new UsabilityEvaluationResult(taskModel, smellGroup.getValue());
-                
-                checkDuplicates(result);
-                
-                if (maxCount < result.getAllSmells().size()) {
-                    Console.traceln(Level.INFO, "filtering for " + maxCount +
-                                    " smells of same type with highest event coverage.");
-                
+                ruleResult = new UsabilityEvaluationResult(taskModel, smellGroup.getValue());
+                
+                checkDuplicates(ruleResult);
+                
+                if ((onlyMostRepresentative) || (maxCount < ruleResult.getAllSmells().size())) {
                     LinkedList<UsabilitySmell> sortedSmells = new LinkedList<>();
                     
-                    for (UsabilitySmell smell : result.getAllSmells()) {
+                    if (onlyMostRepresentative) {
+                        Console.traceln(Level.INFO, "filtering for smells that refer to only most " +
+                                        "representative tasks.");
+                    }
+                    
+                    for (UsabilitySmell smell : ruleResult.getAllSmells()) {
+                        if (onlyMostRepresentative && (smell.getSmellingTask() != null)) {
+                            if (mostRepresentativeTasks == null) {
+                                mostRepresentativeTasks = getMostRepresentativeSequences(taskModel);
+                            }
+                            
+                            if (!mostRepresentativeTasks.contains(smell.getSmellingTask())) {
+                                continue;
+                            }
+                        }
+                        
                         ListIterator<UsabilitySmell> iterator = sortedSmells.listIterator();
 
@@ -116 +139 @@
                         while (iterator.hasNext()) {
                             if (iterator.next().getIntensity().getEventCoverage() <
-                                    smell.getIntensity().getEventCoverage())
+                                smell.getIntensity().getEventCoverage())
                             {
                                 iterator.previous();
@@ -129 +152 @@
                         }
                     
+                    }
+                    
+                    if (maxCount < ruleResult.getAllSmells().size()) {
+                        Console.traceln(Level.INFO, "filtering for " + maxCount +
+                                " smells of same type with highest event coverage.");
+                        
                         while (sortedSmells.size() > maxCount) {
                             sortedSmells.removeLast();
@@ -134 +163 @@
                     }
                 
-                    result = new UsabilityEvaluationResult(taskModel, sortedSmells);
-                    checkDuplicates(result);
-                }
-            
-                interimResults.add(result);
+                    Console.traceln(Level.INFO, sortedSmells.size() + " remaining.");
+                    ruleResult = new UsabilityEvaluationResult(taskModel, sortedSmells);
+                    checkDuplicates(ruleResult);
+                }
+            
+                interimResults.add(ruleResult);
             }
         }
@@ -147 +177 @@
 
         return result;
+    }
+
+    /**
+     * <p>
+     * TODO: comment
+     * </p>
+     *
+     * @param taskModel
+     * @return
+     */
+    private Set<ITask> getMostRepresentativeSequences(ITaskModel taskModel) {
+        Map<Integer, List<ISequence>> coverageCounts = new HashMap<>();
+        Map<ISequence, Set<IEventTaskInstance>> coverages = new HashMap<>();
+        int maxCoverage = 0;
+
+        for (ITask task : taskModel.getTasks()) {
+            if (task instanceof ISequence) {
+                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());
+            }
+        }
+
+        Set<ITask> mostRepresentativeSequences = new HashSet<>();
+
+        for (int i = maxCoverage; i > 0; i--) {
+            List<ISequence> sequencesWithSameCoverage = coverageCounts.get(i);
+
+            if (sequencesWithSameCoverage == null) {
+                continue;
+            }
+
+            for (ISequence sequence : sequencesWithSameCoverage) {
+                mostRepresentativeSequences.add(sequence);
+            }
+            
+            if ((100 * mostRepresentativeSequences.size() / coverages.size()) > 20) {
+                break;
+            }
+        }
+
+        return mostRepresentativeSequences;
     }