source: branches/autoquest-core-tasktrees-alignment/src/main/java/de/ugoe/cs/autoquest/tasktrees/alignment/matrix/ObjectDistanceSubstitionMatrix.java @ 1695

Last change on this file since 1695 was 1695, checked in by rkrimmel, 10 years ago

Made additional calculations optional in substitution matrix..
File size: 7.0 KB
Line 
1package de.ugoe.cs.autoquest.tasktrees.alignment.matrix;
2
3import java.util.HashMap;
4import java.util.HashSet;
5import java.util.Iterator;
6import java.util.LinkedList;
7import java.util.logging.Level;
8
9import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
10import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentHelpers;
11import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.Constants;
12import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
13import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
14import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
15import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
16import de.ugoe.cs.util.console.Console;
17
18public class ObjectDistanceSubstitionMatrix implements SubstitutionMatrix {
19
20        private HashMap<Integer, Integer> idmapping;
21        private TriangleMatrix matrix;
22        private HashSet<ITask> uniqueTasks;
23        private double gapPenalty;
24        private int index = 0;
25        private HashMap<Integer, LinkedList<IEventTaskInstance>> etisOfTasks;
26        private boolean calculateNonTaskInstances = true;
27
28        private double positiveThreshold;
29
30        public ObjectDistanceSubstitionMatrix(HashSet<ITask> uniqueTasks,
31                        float positiveThreshold, int gapPenalty,
32                        boolean calculateNonTaskInstances) {
33                this.uniqueTasks = uniqueTasks;
34                this.positiveThreshold = positiveThreshold;
35                idmapping = new HashMap<Integer, Integer>();
36                etisOfTasks = new HashMap<Integer, LinkedList<IEventTaskInstance>>();
37                matrix = new TriangleMatrix(uniqueTasks.size() + 1);
38                this.gapPenalty = gapPenalty;
39                this.calculateNonTaskInstances = calculateNonTaskInstances;
40
41        }
42
43        public double getGapPenalty() {
44                return gapPenalty;
45        }
46
47        public void setGapPenalty(double gapPenalty) {
48                this.gapPenalty = gapPenalty;
49        }
50
51        private void searchEventTaskInstances() {
52                int count = 0;
53                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
54                        count++;
55                       
56                        ITask task = it.next();
57                        if (!(task instanceof IEventTask)) {
58                                EventTaskInstancesListGenerator etlg = new EventTaskInstancesListGenerator();
59                                task.accept(etlg);
60                                LinkedList<IEventTaskInstance> eventTaskInstances = etlg
61                                                .getEventlist();
62                                etisOfTasks.put(task.getId(), eventTaskInstances);
63                        }
64                }
65
66        }
67
68        public void generate() {
69                if (this.calculateNonTaskInstances) {
70                        Console.traceln(Level.INFO, "   searching EventTasks in Tasks");
71                        searchEventTaskInstances();
72                }
73                Console.traceln(Level.INFO, "   calculating distances");
74                int index1 = -1;
75                int index2 = -1;
76                double distance = 0;
77                int count = 0;
78                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
79                        count++;
80                       
81                        ITask task1 = it.next();
82                        for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) {
83                                ITask task2 = jt.next();
84                                ITaskInstance ti1 = null;
85                                ITaskInstance ti2 = null;
86                                // We just need to the first instance here
87                                if (task1.getInstances().size() > 0) {
88                                        ti1 = (ITaskInstance) task1.getInstances().iterator()
89                                                        .next();
90                                }
91                                if (task2.getInstances().size() > 0) {
92                                        ti2 = (ITaskInstance) task2.getInstances().iterator()
93                                                        .next();
94                                }
95                                IEventTaskInstance eti1 = null;
96                                IEventTaskInstance eti2 = null;
97
98                                if (ti1 instanceof IEventTaskInstance
99                                                && ti2 instanceof IEventTaskInstance) {
100                                        eti1 = (IEventTaskInstance) ti1;
101                                        index1 = getIndex(eti1);
102                                        eti2 = (IEventTaskInstance) ti2;
103                                        index2 = getIndex(eti2);
104                                        distance = distanceBetweenInstances(eti1, eti2);
105                                } else if (ti1 instanceof IEventTaskInstance
106                                                && !(ti2 instanceof IEventTaskInstance)) {
107                                        task1 = ((ITaskInstance) ti1).getTask();
108                                        index2 = getIndex(task2);
109                                        eti1 = (IEventTaskInstance) ti1;
110                                        index1 = getIndex(eti1);
111                                        distance = distanceBetweenTaskAndInstance(task2, eti1);
112                                } else if (!(ti1 instanceof IEventTaskInstance)
113                                                && ti2 instanceof IEventTaskInstance) {
114                                        index1 = getIndex(task1);
115                                        eti2 = (IEventTaskInstance) ti2;
116                                        index2 = getIndex(eti2);
117                                        distance = distanceBetweenTaskAndInstance(task1, eti2);
118                                } else if (!(ti1 instanceof IEventTaskInstance)
119                                                && !(ti2 instanceof IEventTaskInstance)) {
120                                        index1 = getIndex(task1);
121                                        index2 = getIndex(task2);
122                                        distance = distanceBetweenTasks(task1, task2);
123                                } else {
124                                        System.out.println("Unknown error");
125                                }
126
127                                matrix.set(index1, index2, distance);
128
129                        }
130                }
131        }
132
133        private double distanceBetweenTaskAndInstance(ITask task1,
134                        IEventTaskInstance eti1) {
135                if (this.calculateNonTaskInstances) {
136                        float tmpDistance = 0;
137                        LinkedList<IEventTaskInstance> eventTaskInstances = etisOfTasks
138                                        .get(task1.getId());
139                        for (Iterator<IEventTaskInstance> it = eventTaskInstances
140                                        .iterator(); it.hasNext();) {
141                                IEventTaskInstance eti2 = it.next();
142                                int taskId1 = eti1.getTask().getId();
143                                int taskId2 = eti2.getTask().getId();
144                                if (scoreExists(taskId1, taskId2)) {
145                                        tmpDistance += getScore(taskId1, taskId2);
146                                } else {
147                                        double dist = distanceBetweenInstances(eti1, eti2);
148                                        matrix.set(getIndex(eti1), getIndex(eti2), dist);
149                                        tmpDistance += dist;
150                                }
151                        }
152                        return tmpDistance / eventTaskInstances.size();
153                } else {
154                        return 0;
155                }
156        }
157
158        public boolean scoreExists(int id, int id2) {
159                return idmapping.containsKey(id) && idmapping.containsKey(id2);
160        }
161
162        private double distanceBetweenTasks(ITask task1, ITask task2) {
163                if (this.calculateNonTaskInstances) {
164                        LinkedList<IEventTaskInstance> eventTaskInstances = etisOfTasks
165                                        .get(task1.getId());
166                        float tmpDistance = 0;
167                        for (Iterator<IEventTaskInstance> it = eventTaskInstances
168                                        .iterator(); it.hasNext();) {
169                                IEventTaskInstance eti1 = it.next();
170                                tmpDistance += distanceBetweenTaskAndInstance(task2, eti1);
171                        }
172
173                        return tmpDistance / eventTaskInstances.size();
174                } else {
175                        return 0;
176                }
177        }
178
179        private int getIndex(ITask task) {
180                int tempindex = -1;
181
182                if (!idmapping.containsKey(task.getId())) {
183                        idmapping.put(task.getId(), index);
184                        tempindex = index;
185                        index++;
186                } else {
187                        tempindex = idmapping.get(task.getId());
188                }
189
190                return tempindex;
191        }
192
193        private int getIndex(IEventTaskInstance eti) {
194                int tempindex = -1;
195                if (!idmapping.containsKey(eti.getTask().getId())) {
196                        idmapping.put(eti.getTask().getId(), index);
197                        tempindex = index;
198                        index++;
199                } else {
200                        tempindex = idmapping.get(eti.getTask().getId());
201                }
202                return tempindex;
203        };
204
205        private double distanceBetweenInstances(IEventTaskInstance eti1,
206                        IEventTaskInstance eti2) {
207                IGUIElement first = (IGUIElement) eti1.getEvent().getTarget();
208                IGUIElement second = (IGUIElement) eti2.getEvent().getTarget();
209                float distance = -1 * AlignmentHelpers.distanceBetween(first, second);
210                distance += positiveThreshold;
211                return distance;
212        }
213
214        public String toString() {
215                return matrix.toString();
216        }
217
218        public double getScore(int taskId1, int taskId2) {
219                if (taskId1 == Constants.GAP_SYMBOL
220                                || taskId1 == Constants.UNMATCHED_SYMBOL
221                                || taskId2 == Constants.GAP_SYMBOL
222                                || taskId2 == Constants.UNMATCHED_SYMBOL) {
223                        return 0.0;
224                } else {
225                        Integer first = idmapping.get(taskId1);
226                        Integer second = idmapping.get(taskId2);
227                        return matrix.get(first, second);
228                }
229
230        }
231
232}
Note: See TracBrowser for help on using the repository browser.