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

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

Removing useless code.
File size: 8.8 KB
Line 
1package de.ugoe.cs.autoquest.tasktrees.alignment.matrix;
2
3import java.io.Serializable;
4import java.util.HashMap;
5import java.util.HashSet;
6import java.util.Iterator;
7import java.util.LinkedList;
8import java.util.logging.Level;
9
10import de.ugoe.cs.autoquest.eventcore.guimodel.IGUIElement;
11import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.AlignmentHelpers;
12import de.ugoe.cs.autoquest.tasktrees.alignment.algorithms.Constants;
13import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTask;
14import de.ugoe.cs.autoquest.tasktrees.treeifc.IEventTaskInstance;
15import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
16import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
17import de.ugoe.cs.util.console.Console;
18
19
20
21public class ObjectDistanceSubstitionMatrix implements SubstitutionMatrix,Serializable {
22
23        /**
24         *
25         */
26        private static final long serialVersionUID = -4253258274617754083L;
27        private HashMap<Integer, Integer> idmapping;
28        private ITriangleMatrix matrix;
29        private HashSet<ITask> uniqueTasks;
30        private float gapPenalty;
31        private int index = 0;
32        private HashMap<Integer, LinkedList<IEventTaskInstance>> etisOfTasks;
33        private boolean calculateNonTaskInstances = true;
34        private int firstRoundMaxIndex = 0;
35
36        private double positiveThreshold;
37
38        public ObjectDistanceSubstitionMatrix(
39                float positiveThreshold, int gapPenalty,
40                boolean calculateNonTaskInstances) {
41                this.positiveThreshold = positiveThreshold;
42                idmapping = new HashMap<Integer, Integer>();
43                etisOfTasks = new HashMap<Integer, LinkedList<IEventTaskInstance>>();
44                this.gapPenalty = gapPenalty;
45                this.calculateNonTaskInstances = calculateNonTaskInstances;
46
47        }
48
49        public float getGapPenalty() {
50                return gapPenalty;
51        }
52
53        public void setGapPenalty(float gapPenalty) {
54                this.gapPenalty = gapPenalty;
55        }
56
57        //TODO: Merge this with updateEventTaskInstances
58        private void searchEventTaskInstances() {
59                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
60                        ITask task = it.next();
61                        if (!(task instanceof IEventTask)) {
62                                EventTaskInstancesListGenerator etlg = new EventTaskInstancesListGenerator();
63                                task.accept(etlg);
64                                LinkedList<IEventTaskInstance> eventTaskInstances = etlg
65                                                .getEventlist();
66                                etisOfTasks.put(task.getId(), eventTaskInstances);
67                        }
68                }
69        }
70       
71        public void updateEventTaskInstances(LinkedList<ITask> newTasks){
72                for (Iterator<ITask> it = newTasks.iterator();it.hasNext();) {
73                        ITask task = it.next();
74                        if (!(task instanceof IEventTask)) {
75                                EventTaskInstancesListGenerator etlg = new EventTaskInstancesListGenerator();
76                                task.accept(etlg);
77                                LinkedList<IEventTaskInstance> eventTaskInstances = etlg
78                                                .getEventlist();
79                                etisOfTasks.put(task.getId(), eventTaskInstances);
80                        }
81                }
82        }
83       
84        //Just Calculate the distance between the new tasks and the matrix.
85        public void update(LinkedList<ITask> newTasks) {
86
87                if (this.calculateNonTaskInstances) {
88                        try {
89                                matrix.increaseSize(newTasks.size());
90                                System.out.println("Subsitution matrix size is now " + matrix.size()*(matrix.size()+1)/2);
91                                Console.traceln(Level.INFO, "searching EventTasks in Tasks");
92                        } catch (Exception e) {
93                                Console.logException(e);
94                        }
95                        this.updateEventTaskInstances(newTasks);
96                        for(Iterator<ITask> it = newTasks.iterator();it.hasNext();) {
97                                ITask task1 = it.next();
98                                for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) {
99                                        ITask task2 = jt.next();
100                                        computeDistance(task1,task2);
101                                }
102                        }
103                }
104        }
105
106        private void computeDistance(ITask task1, ITask task2) {
107                int index1 = -1;
108                int index2 = -1;
109                float distance = 0;
110                ITaskInstance ti1 = null;
111                ITaskInstance ti2 = null;
112                // We just need to the first instance here
113                if (task1.getInstances().size() > 0) {
114                        ti1 = (ITaskInstance) task1.getInstances().iterator()
115                                        .next();
116                }
117                if (task2.getInstances().size() > 0) {
118                        ti2 = (ITaskInstance) task2.getInstances().iterator()
119                                        .next();
120                }
121                IEventTaskInstance eti1 = null;
122                IEventTaskInstance eti2 = null;
123
124                if (ti1 instanceof IEventTaskInstance
125                                && ti2 instanceof IEventTaskInstance) {
126                        eti1 = (IEventTaskInstance) ti1;
127                        index1 = getIndex(eti1);
128                        eti2 = (IEventTaskInstance) ti2;
129                        index2 = getIndex(eti2);
130                        distance = distanceBetweenInstances(eti1, eti2);
131                } else if (ti1 instanceof IEventTaskInstance
132                                && !(ti2 instanceof IEventTaskInstance)) {
133                        task1 = ((ITaskInstance) ti1).getTask();
134                        index2 = getIndex(task2);
135                        eti1 = (IEventTaskInstance) ti1;
136                        index1 = getIndex(eti1);
137                        distance = distanceBetweenTaskAndInstance(task2, eti1);
138                } else if (!(ti1 instanceof IEventTaskInstance)
139                                && ti2 instanceof IEventTaskInstance) {
140                        index1 = getIndex(task1);
141                        eti2 = (IEventTaskInstance) ti2;
142                        index2 = getIndex(eti2);
143                        distance = distanceBetweenTaskAndInstance(task1, eti2);
144                } else if (!(ti1 instanceof IEventTaskInstance)
145                                && !(ti2 instanceof IEventTaskInstance)) {
146                        index1 = getIndex(task1);
147                        index2 = getIndex(task2);
148                        distance = distanceBetweenTasks(task1, task2);
149                } else {
150                        System.out.println("Unknown error");
151                }
152                matrix.set(index1, index2, distance);
153        }
154       
155       
156        public void generate(HashSet<ITask> uniqueTasks) {
157                this.uniqueTasks = uniqueTasks;
158                if (this.calculateNonTaskInstances) {
159                        matrix = new DynamicTriangleMatrix(uniqueTasks.size() + 1);
160                        Console.traceln(Level.INFO, "searching EventTasks in Tasks");
161                        searchEventTaskInstances();
162                }
163                else{
164                        matrix = new StaticTriangleMatrix(uniqueTasks.size()+1);
165                }
166                matrix.initialize(0);
167                     
168                int count=0;
169                int size=uniqueTasks.size();
170                for (Iterator<ITask> it = uniqueTasks.iterator(); it.hasNext();) {
171                        ITask task1 = it.next();
172                        count++;
173                        if((count%(size/100)==0)) {
174                                Console.traceln(Level.INFO,(Math.round((float) count/size*100))+ "%");
175                        }
176                        for (Iterator<ITask> jt = uniqueTasks.iterator(); jt.hasNext();) {
177                                ITask task2 = jt.next();
178                                computeDistance(task1,task2);
179                        }
180                }
181                this.firstRoundMaxIndex=index;
182        }
183       
184               
185
186       
187       
188
189        private float distanceBetweenTaskAndInstance(ITask task1,
190                        IEventTaskInstance eti1) {
191                if (this.calculateNonTaskInstances) {
192                        float tmpDistance = 0;
193                        //System.out.println(etisOfTasks);
194                        LinkedList<IEventTaskInstance> eventTaskInstances = etisOfTasks
195                                        .get(task1.getId());
196                        for (Iterator<IEventTaskInstance> it = eventTaskInstances
197                                        .iterator(); it.hasNext();) {
198                                IEventTaskInstance eti2 = it.next();
199                                //int taskId1 = eti1.getTask().getId();
200                                //int taskId2 = eti2.getTask().getId();
201                                //if (scoreExists(taskId1, taskId2)) {
202                                //      tmpDistance += getScore(taskId1, taskId2);
203                                //} else {
204                                        float dist = distanceBetweenInstances(eti1, eti2);
205                                        matrix.set(getIndex(eti1), getIndex(eti2), dist);
206                                        tmpDistance += dist;
207                                //}
208                        }
209                        return tmpDistance / eventTaskInstances.size();
210                } else {
211                        return 0;
212                }
213        }
214
215        //public boolean scoreExists(int id, int id2) {
216                //return idmapping.containsKey(id) && idmapping.containsKey(id2);
217        //      return false;
218        //}
219
220        private float distanceBetweenTasks(ITask task1, ITask task2) {
221                if (this.calculateNonTaskInstances) {
222                        LinkedList<IEventTaskInstance> eventTaskInstances = etisOfTasks
223                                        .get(task1.getId());
224                        float tmpDistance = 0;
225                        for (Iterator<IEventTaskInstance> it = eventTaskInstances
226                                        .iterator(); it.hasNext();) {
227                                IEventTaskInstance eti1 = it.next();
228                                tmpDistance += distanceBetweenTaskAndInstance(task2, eti1);
229                        }
230
231                        return tmpDistance / eventTaskInstances.size();
232                } else {
233                        return 0;
234                }
235        }
236
237        synchronized private int getIndex(ITask task) {
238                int tempindex = -1;
239
240                if (!idmapping.containsKey(task.getId())) {
241                       
242                        idmapping.put(task.getId(), index);
243                        tempindex = index;
244                        index++;
245                } else {
246                        tempindex = idmapping.get(task.getId());
247                }
248
249                return tempindex;
250        }
251
252        synchronized private int getIndex(IEventTaskInstance eti) {
253                int tempindex = -1;
254                if (!idmapping.containsKey(eti.getTask().getId())) {
255                        idmapping.put(eti.getTask().getId(), index);
256                        tempindex = index;
257                        index++;
258                } else {
259                        tempindex = idmapping.get(eti.getTask().getId());
260                }
261                return tempindex;
262        };
263
264        private float distanceBetweenInstances(IEventTaskInstance eti1,
265                        IEventTaskInstance eti2) {
266                IGUIElement first = (IGUIElement) eti1.getEvent().getTarget();
267                IGUIElement second = (IGUIElement) eti2.getEvent().getTarget();
268                float distance = -1 * AlignmentHelpers.distanceBetween(first, second);
269                distance += positiveThreshold;
270                return distance;
271        }
272
273        public String toString() {
274                return matrix.toString();
275        }
276
277        public float getScore(int taskId1, int taskId2) {
278                if (taskId1 == Constants.GAP_SYMBOL
279                                || taskId1 == Constants.UNMATCHED_SYMBOL
280                                || taskId2 == Constants.GAP_SYMBOL
281                                || taskId2 == Constants.UNMATCHED_SYMBOL) {
282                        return 0;
283                } else if(this.calculateNonTaskInstances==false &&     
284                                (taskId1>this.firstRoundMaxIndex
285                                || taskId2>this.firstRoundMaxIndex)) {
286                        return 0;
287                } else {
288                        Integer first = idmapping.get(taskId1);
289                        Integer second = idmapping.get(taskId2);
290                        return matrix.get(first, second);
291                }
292
293        }
294}
Note: See TracBrowser for help on using the repository browser.