Changeset 2132

Timestamp:

08/24/16 10:17:41 (8 years ago)

Author:

pharms

Message:

• added possibility to select the minimal amount of action instances a detected sequence must cover

Location:

trunk

Files:

• autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManager.java (modified) (7 diffs)
• autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/CondenseSimilarTasksRule.java (modified) (1 diff)
• autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java (modified) (6 diffs)
• autoquest-ui-core/src/main/java/de/ugoe/cs/autoquest/commands/usability/CMDgenerateTaskTree.java (modified) (3 diffs)
• autoquest-ui-core/src/main/resources/manuals/generateTaskTree (modified) (1 diff)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/manager/TaskTreeManager.java

@@ -16 +16 @@
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.logging.Level;
 
 import de.ugoe.cs.autoquest.eventcore.Event;
+import de.ugoe.cs.autoquest.tasktrees.taskequality.TaskEquality;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskModel;
@@ -72 +75 @@
     /**
      * <p>
+     * The default task equality considered when comparing task instances initially
+     * </p>
+     */
+    private TaskEquality minimalTaskEquality = TaskEquality.SEMANTICALLY_EQUAL;
+
+    /**
+     * <p>
+     * If this flag is set, then the task tree manager will not create new event tasks for any
+     * events. Instead, it will check using the hashcode and equal methods of the provided events
+     * if a certain event has already occurred, and if so, the corresponding event task will be
+     * reused.
+     * </p>
+     */
+    private boolean useEventEqualityForTaskComparison;
+    
+    /**
+     * <p>
+     * the minimum number of event task instances a sequence must cover to still detect it as a
+     * representative task
+     * </p>
+     */
+    private int minimumSequenceCoverage;;
+
+    /**
+     * <p>
+     * If the flag {@link #useEventEqualityForTaskComparison} is set, then here the task tree
+     * manager stores the already created event tasks.
+     * </p>
+     */
+    private Map<Event, IEventTask> eventTasks = new HashMap<>();
+
+    /**
+     * <p>
      * initializes the task tree manager
      * </p>
      */
     public TaskTreeManager() {
-        sessions = new LinkedList<IUserSession>();
+        this.sessions = new LinkedList<IUserSession>();
     }
 
@@ -96 +132 @@
      *                               single events
      */
-    public synchronized ITaskModel createTaskModel(Collection<List<Event>> newSessions) {
+    public synchronized ITaskModel createTaskModel(Collection<List<Event>> newSessions,
+                                                   boolean useEventEqualityForTaskComparison,
+                                                   int     minimumSequenceCoverage)
+    {
         if ((currentSession != null) || (sessions.size() > 0)) {
             throw new IllegalStateException("do not mix calls to this method with calls to the " +
@@ -102 +141 @@
                                             "variant instead.");
         }
+        
+        this.useEventEqualityForTaskComparison = useEventEqualityForTaskComparison;
+        
+        if (useEventEqualityForTaskComparison) {
+            // if we do this, we also need to consider identity of event tasks afterwards
+            minimalTaskEquality = TaskEquality.IDENTICAL;
+        }
+        
+        this.minimumSequenceCoverage = minimumSequenceCoverage;
         
         for (List<Event> newSession : newSessions) {
@@ -117 +165 @@
     /**
      * <p>
+     * call {@link #createTaskModel(Collection, boolean, int)} with false for use event equality
+     * for comparison and 0 for the minimum number of covered events per sequence
+     * </p>
+     * 
+     * @param newSessions the user sessions of which the task model shall be created
+     * 
+     * @return the task model created from the user sessions
+     * 
+     * @throws IllegalStateException if the task manager is already used by providing it with
+     *                               single events
+     */
+    public synchronized ITaskModel createTaskModel(Collection<List<Event>> newSessions) {
+        return createTaskModel(newSessions, false, 0);
+    }
+
+    /**
+     * <p>
      * handles a single event that occurred in a user session.
      * </p>
@@ -124 +189 @@
     public void handleNewEvent(Event event) {
         assertSessionSequence();
-        String description = event.getType().getName() + " \u21D2 " + event.getTarget();
-        IEventTask eventTask = taskFactory.createNewEventTask(description);
-        taskBuilder.addExecutedTask
-            (currentSession, taskFactory.createNewTaskInstance(eventTask, event));
+        
+        if (!useEventEqualityForTaskComparison) {
+            String description = event.getType().getName() + " \u21D2 " + event.getTarget();
+            IEventTask eventTask = taskFactory.createNewEventTask(description);
+            taskBuilder.addExecutedTask
+                (currentSession, taskFactory.createNewTaskInstance(eventTask, event));
+        }
+        else {
+            IEventTask eventTask = eventTasks.get(event);
+            if (eventTask == null) {
+                String description = event.getType().getName() + " \u21D2 " + event.getTarget();
+                eventTask = taskFactory.createNewEventTask(description);
+                eventTasks.put(event, eventTask);
+            }
+            
+            taskBuilder.addExecutedTask
+                (currentSession, taskFactory.createNewTaskInstance(eventTask, event));
+        }
     }
 
@@ -157 +236 @@
             (Level.INFO, "applying temporal relationship generation rules for detecting tasks");
         
-        ComponentManager.getTemporalRelationshipRuleManager().applyTaskDetectionRule(sessions);
+        ComponentManager.getTemporalRelationshipRuleManager().applyTaskDetectionRule
+            (sessions, minimalTaskEquality, minimumSequenceCoverage);
 
         return taskFactory.createTaskModel(sessions);

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/CondenseSimilarTasksRule.java

@@ -444 +444 @@
         
         new SequenceForTaskDetectionRule
-            (TaskEquality.IDENTICAL, taskFactory, taskBuilder).apply(flattenedSessionList);
+            (TaskEquality.IDENTICAL, taskFactory, taskBuilder, 0).apply(flattenedSessionList);
         
         Map<ITaskInstance, ITaskInstance> replacements = new HashMap<ITaskInstance, ITaskInstance>();

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TemporalRelationshipRuleManager.java

@@ -25 +25 @@
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskBuilder;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskFactory;
-import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession;
 import de.ugoe.cs.util.console.Console;
@@ -102 +101 @@
     /**
      * <p>
-     * the temporal relationship rules known to the manager that are executed on whole sessions.
-     * The rules are applied in the order they occur in this list.
-     * </p>
-     */
-    private ISessionScopeRule[] sessionScopeRules;
-
-    /**
-     * <p>
-     * the temporal relationship rules known to the manager that are executed on whole sub trees.
-     * The rules are applied in the order they occur in this list.
-     * </p>
-     */
-    private ITaskInstanceScopeRule[] taskScopeRules;
-
-    /**
-     * <p>
      * initialize the manager
      * </p>
@@ -144 +127 @@
         frameFilter.add(IDialog.class);
         //frameFilter.add(ICanvas.class);
-
-        sessionScopeRules = new ISessionScopeRule[] {
-            new SequenceForTaskDetectionRule
-                (TaskEquality.SEMANTICALLY_EQUAL, taskFactory, taskBuilder),
-            new CondenseSimilarTasksRule
-                (TaskEquality.SEMANTICALLY_EQUAL, taskFactory, taskBuilder),
-            /*new DefaultTaskSequenceDetectionRule
-                (NodeEquality.SYNTACTICALLY_EQUAL, taskFactory, taskTreeBuilder),
-            new DefaultTaskSequenceDetectionRule
-                (NodeEquality.LEXICALLY_EQUAL, taskFactory, taskTreeBuilder),*/
-            /*new TreeScopeWrapperRule
-                (new DefaultIterationDetectionRule
-                    (NodeEquality.LEXICALLY_EQUAL, taskFactory, taskTreeBuilder)),
-            new TreeScopeWrapperRule
-                (new DefaultIterationDetectionRule
-                    (NodeEquality.SYNTACTICALLY_EQUAL, taskFactory, taskTreeBuilder)),
-            new TreeScopeWrapperRule
-                (new DefaultIterationDetectionRule
-                    (NodeEquality.SEMANTICALLY_EQUAL, taskFactory, taskTreeBuilder))*/
-        };
-        
-        //treeScopeRules.add(new DefaultGuiElementSequenceDetectionRule(frameFilter));
-
-        taskScopeRules = new ITaskInstanceScopeRule[] {
-            //new SequenceOnGuiElementDetectionRule(taskFactory, taskTreeBuilder),
-            //new EventSequenceOnSameTargetDetectionRule(taskFactory, taskTreeBuilder),
-            //new TrackBarSelectionDetectionRule(taskFactory, taskBuilder),
-            //new DefaultGuiEventSequenceDetectionRule(taskFactory, taskTreeBuilder),
-        };
-
-    }
-
-    /**
-     * <p>
-     * applies the known rules to the provided sessions. For the creation of further tasks,
-     * the provided builder and task factory are utilized. The method expects, that no more data
-     * is available and, therefore, finalizes the rule application.
-     * </p>
-     * 
-     * @param sessions  the sessions to be processed
-     */
-    public void applyRules(List<IUserSession> sessions) {
-        applyRules(sessionScopeRules, sessions, "");
     }
 
@@ -197 +137 @@
      * @param sessions  the sessions to be processed
      */
-    public void applyTaskDetectionRule(List<IUserSession> sessions) {
+    public void applyTaskDetectionRule(List<IUserSession> sessions,
+                                       TaskEquality       minimalTaskEquality,
+                                       int                minimumSequenceCoverage)
+    {
         ISessionScopeRule[] rules = new ISessionScopeRule[] {
-            new SequenceForTaskDetectionRule
-                (TaskEquality.SEMANTICALLY_EQUAL, taskFactory, taskBuilder)
+            new SequenceForTaskDetectionRule(minimalTaskEquality, taskFactory, taskBuilder,
+                                             minimumSequenceCoverage)
         };
         
@@ -261 +204 @@
                     
                     //dumpTask(parent, "");
-
-                    for (ITaskInstance newParent : result.getNewlyCreatedTaskInstances()) {
-                        noOfRuleApplications +=
-                            applyRules(taskScopeRules, newParent, logIndent + "  ");
-                    }
                 }
             }
@@ -271 +209 @@
                    (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED));
 
-        }
-
-        if (noOfRuleApplications <= 0) {
-            Console.traceln(Level.FINE, logIndent + "no rules applied --> no temporal " +
-                            "relationship generated");
-        }
-
-        return noOfRuleApplications;
-    }
-
-    /**
-     * <p>
-     * applies the known rules to the provided parent task. For the creation of further tasks,
-     * the provided builder and task factory are utilized. If the finalize parameter is true, the
-     * rule application is finalized as far as possible without waiting for further data. If it is
-     * false, the rule application is broken up at the first rule returning, that its application
-     * would be feasible. The method calls itself for each parent task created through the rule
-     * application. In this case, the finalize parameter is always true.
-     * </p>
-     * 
-     * @param parent       the parent task to apply the rules on
-     * @param finalize     used to indicate, if the rule application shall break up if a rule would
-     *                     be feasible if further data was available, or not.
-     * @param logIndent    simply used for logging purposes to indent the log messages depending
-     *                     on the recursion depth of calling this method.
-     */
-    private int applyRules(ITaskInstanceScopeRule[] rules,
-                           ITaskInstance                taskInstance,
-                           String                       logIndent)
-    {
-        Console.traceln(Level.FINER, logIndent + "applying rules on " + taskInstance);
-
-        int noOfRuleApplications = 0;
-
-        for (ITaskInstanceScopeRule rule : rules) {
-            RuleApplicationResult result;
-            do {
-                Console.traceln
-                    (Level.FINER, logIndent + "trying rule " + rule + " on " + taskInstance);
-                result = rule.apply(taskInstance);
-
-                if ((result != null) &&
-                    (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED))
-                {
-                    Console.traceln
-                        (Level.FINE, logIndent + "applied rule " + rule + " on " + taskInstance);
-                    noOfRuleApplications++;
-                    
-                    //dumpTask(parent, "");
-
-                    for (ITaskInstance newParent : result.getNewlyCreatedTaskInstances()) {
-                        noOfRuleApplications +=
-                            applyRules(taskScopeRules, newParent, logIndent + "  ");
-                    }
-                }
-            }
-            while ((result != null) &&
-                   (result.getRuleApplicationStatus() == RuleApplicationStatus.FINISHED));
         }
 

trunk/autoquest-ui-core/src/main/java/de/ugoe/cs/autoquest/commands/usability/CMDgenerateTaskTree.java

@@ -45 +45 @@
     @Override
     public String help() {
-        return "generateTaskTree <sequences> {<tasktree>}";
+        return "generateTaskTree <sequences> {<tasktree>} {-considerEventEquality} " +
+            "{-minimumSequenceCoverage=<some integer>}";
     }
 
@@ -56 +57 @@
     @Override
     public void run(List<Object> parameters) {
-        String sequencesName;
-        String tasktreeName;
+        String sequencesName = null;
+        String tasktreeName = null;
+        boolean useEventEqualityForTaskComparison = false;
+        int minimumSequenceCoverage = 0;
+        
         try {
-            sequencesName = (String) parameters.get(0);
-            if (parameters.size() > 1) {
-                tasktreeName = (String) parameters.get(1);
-            }
-            else {
-                tasktreeName = "tasktree";
+            for (int i = 0; i < parameters.size(); i++) {
+                String parameter = (String) parameters.get(i);
+                if (!parameter.startsWith("-")) {
+                    if (sequencesName == null) {
+                        sequencesName = parameter;
+                    }
+                    else if (tasktreeName == null) {
+                        tasktreeName = parameter;
+                    }
+                    else {
+                        throw new IllegalArgumentException("unrecognized parameter: " + parameter);
+                    }
+                }
+                else {
+                    if ("-considerEventEquality".equals(parameter)) {
+                        useEventEqualityForTaskComparison = true;
+                    }
+                    else if (parameter.startsWith("-minimumSequenceCoverage=")) {
+                        try {
+                            minimumSequenceCoverage = Integer.parseInt
+                                (parameter.substring("-minimumSequenceCoverage=".length()));
+                        }
+                        catch (Exception e) {
+                            throw new IllegalArgumentException
+                                ("invalid value for parameter minimumSequenceCoverage: " +
+                                 parameter.substring("-minimumSequenceCoverage=".length()));
+                        }
+                    }
+                    else {
+                        throw new IllegalArgumentException("unrecognized parameter: " + parameter);
+                    }
+                }
             }
         }
+        catch (IllegalArgumentException e) {
+            throw e;
+        }
         catch (Exception e) {
+            throw new IllegalArgumentException("could not process parameters", e);
+        }
+        
+        if (sequencesName == null) {
             throw new IllegalArgumentException("must provide a sequences name");
+        }
+        
+        if (tasktreeName == null) {
+            tasktreeName = "tasktree";
         }
 
@@ -84 +125 @@
         sequences = (Collection<List<Event>>) dataObject;
         
-        ITaskModel taskModel = new TaskTreeManager().createTaskModel(sequences);
+        ITaskModel taskModel = new TaskTreeManager().createTaskModel
+            (sequences, useEventEqualityForTaskComparison, minimumSequenceCoverage);
         
         if (GlobalDataContainer.getInstance().addData(tasktreeName, taskModel)) {

trunk/autoquest-ui-core/src/main/resources/manuals/generateTaskTree

@@ -5 +5 @@
 <tasktree> name of the object to store the task model in (defaults to "tasktree")
 
+-considerEventEquality
+    to be provided if the events equal method shall be used for event comparison. This can
+    accelerate the comparison process
+
+-minimumSequenceCoverage=<some integer>
+    can be used to define a minimum number of events that shall be covered by the detected
+    sequences. This prevents the detection of sequences that mainly represent noise.
+
 Example(s)
 generateTaskTree sequences tasktree
+generateTaskTree sequences -considerEventEquality
+generateTaskTree sequences tasktree -considerEventEquality -minimumSequenceCoverage=10