← Back to branch summary

~ubuntu-branches/ubuntu/utopic/sikuli/utopic

« back to all changes in this revision

Viewing changes to sikuli-script/src/main/java/org/sikuli/script/EventManager.java

  • Committer: Bazaar Package Importer
  • Author(s): Gilles Filippini
  • Date: 2011-04-16 00:23:53 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110416002353-cn79cto3c03z5jx1
Tags: 1.0~x~rc2-dfsg1-1
* New upstream release:
  + Redesigned user interface for Sikuli-IDE
  + Support for extensions for Sikuli Script

* debian/control, debian/copyright:
  The package is now maintained by the Debian Java maintainers Team

Show diffs side-by-side

added added

removed removed

Lines of Context:
sikuli-script/src/main/java/org/sikuli/script/EventManager.java
1
1
package org.sikuli.script;
2
2
 
3
 
import java.awt.*;
4
3
import java.util.*;
5
4
import java.io.File;
6
5
import java.io.IOException;
 
6
import java.awt.AWTException;
 
7
 
 
8
import org.sikuli.script.natives.FindInput;
 
9
import org.sikuli.script.natives.FindResult;
 
10
import org.sikuli.script.natives.FindResults;
 
11
import org.sikuli.script.natives.Mat;
 
12
import org.sikuli.script.natives.Vision;
7
13
 
8
14
public class EventManager {
9
 
   final static int APPEAR = 0;
10
 
   final static int VANISH = 1;
11
 
   final static int CHANGE = 2;
12
 
   private static EventManager _instance = null;
13
 
   private long _c_instance = 0;
14
 
   private Map<Integer, SikuliEventObserver> _obMap;
 
15
   protected enum State {
 
16
      UNKNOWN, APPEARED, VANISHED
 
17
   }
 
18
 
15
19
   private Region _region;
16
 
 
17
 
   static {
18
 
      try{
19
 
         System.loadLibrary("VisionProxy");
20
 
         System.out.println("EventManager loaded.");
21
 
      }
22
 
      catch(Exception e){
23
 
         e.printStackTrace();
24
 
      }
25
 
   }
26
 
 
27
 
   /*
28
 
   public static EventManager getInstance(){
29
 
      if(_instance==null)
30
 
         _instance = new EventManager();
31
 
      return _instance;
32
 
   }
33
 
   */
 
20
   private Mat _lastImgMat = null;
 
21
   private Map<Object, State> _state;
 
22
   private Map<Object, Match> _lastMatch;
 
23
   private Map<Object, SikuliEventObserver> _appearOb, _vanishOb;
 
24
   private Map<Integer, SikuliEventObserver> _changeOb;
 
25
   private int _minChanges;
 
26
 
34
27
 
35
28
   public EventManager(Region region){
36
 
      _c_instance = createEventManager();
37
 
      _obMap = new HashMap<Integer, SikuliEventObserver>();
38
29
      _region = region;
 
30
      _state = new HashMap<Object, State>();
 
31
      _lastMatch = new HashMap<Object, Match>();
 
32
      _appearOb = new HashMap<Object, SikuliEventObserver>();
 
33
      _vanishOb = new HashMap<Object, SikuliEventObserver>();
 
34
      _changeOb = new HashMap<Integer, SikuliEventObserver>();
39
35
   }
40
36
 
41
37
   private <PSC> float getSimiliarity(PSC ptn){
49
45
      return similarity;
50
46
   }
51
47
 
52
 
   private <PSC> String getFilename(PSC ptn){
53
 
      String fname = null;
54
 
      if( ptn instanceof Pattern ){
55
 
         fname = ((Pattern)ptn).imgURL;
56
 
      }
57
 
      else if( ptn instanceof String){
58
 
         fname = (String)ptn;
59
 
      }
60
 
      if( !(new File(fname)).exists() && Settings.BundlePath!=null)
61
 
         fname = Settings.BundlePath + File.separator + fname;
62
 
      return fname;
63
 
   }
64
 
 
65
 
   private int getObserverId(SikuliEventObserver ob){
66
 
      int id = ob.hashCode();
67
 
      while(_obMap.containsKey(id)){
68
 
         id+=(int)(Math.random()*100);
69
 
      }
70
 
      _obMap.put(id, ob);
71
 
      return id;
72
 
   }
73
 
 
74
 
   private SikuliEventObserver getObserverFromId(int id){
75
 
      return _obMap.get(id);
76
 
   }
77
 
 
78
48
   public <PSC> void addAppearObserver(PSC ptn, SikuliEventObserver ob){
79
 
      int handler_id = getObserverId(ob);
80
 
      addObserver(_c_instance, APPEAR, getFilename(ptn), getSimiliarity(ptn),
81
 
               handler_id, 0, 0, _region.w, _region.h);
 
49
      _appearOb.put(ptn, ob);
 
50
      _state.put(ptn, State.UNKNOWN);
82
51
   }
83
52
 
84
53
   public <PSC> void addVanishObserver(PSC ptn, SikuliEventObserver ob){
85
 
      int handler_id = getObserverId(ob);
86
 
      addObserver(_c_instance, VANISH, getFilename(ptn), getSimiliarity(ptn),
87
 
            handler_id, 0, 0, _region.w, _region.h);
88
 
   
89
 
   }
90
 
 
91
 
   public void addChangeObserver(SikuliEventObserver ob){
92
 
      int handler_id = getObserverId(ob);
93
 
      float change_threshold = -1f;
94
 
      addObserver(_c_instance, CHANGE, "", change_threshold, 
95
 
            handler_id, 0, 0, _region.w, _region.h);
 
54
      _vanishOb.put(ptn, ob);
 
55
      _state.put(ptn, State.UNKNOWN);
 
56
   }
 
57
 
 
58
   public void addChangeObserver(int threshold, SikuliEventObserver ob){
 
59
      _changeOb.put(new Integer(threshold), ob);
 
60
      _minChanges = getMinChanges();
 
61
   }
 
62
 
 
63
   protected void callAppearObserver(Object ptn, Match m){
 
64
      AppearEvent se = new AppearEvent(ptn, m, _region);
 
65
      SikuliEventObserver ob = _appearOb.get(ptn);
 
66
      ob.targetAppeared(se);
 
67
   }
 
68
 
 
69
   protected void callVanishObserver(Object ptn, Match m){
 
70
      VanishEvent se = new VanishEvent(ptn, m, _region);
 
71
      SikuliEventObserver ob = _vanishOb.get(ptn);
 
72
      ob.targetVanished(se);
 
73
   }
 
74
 
 
75
 
 
76
   protected void checkPatterns(ScreenImage img){
 
77
      Finder finder = new Finder(img, _region);
 
78
      for(Object ptn : _state.keySet()){
 
79
         try{
 
80
            finder.find(ptn);
 
81
            Match m = null;
 
82
            boolean hasMatch = false;
 
83
            if(finder.hasNext()){
 
84
               m = finder.next();
 
85
               if(m.getScore() >= getSimiliarity(ptn)){
 
86
                  hasMatch = true;
 
87
                  _lastMatch.put(ptn, m);
 
88
               }
 
89
            }
 
90
            Debug.log(9, "check pattern: " + _state.get(ptn) + " match:" + hasMatch);
 
91
            if(_appearOb.containsKey(ptn)){
 
92
               if(_state.get(ptn) != State.APPEARED && hasMatch)
 
93
                  callAppearObserver(ptn, m);
 
94
            }
 
95
            if(_vanishOb.containsKey(ptn)){
 
96
               if(_state.get(ptn) != State.VANISHED && !hasMatch){
 
97
                  callVanishObserver(ptn, _lastMatch.get(ptn));
 
98
               }
 
99
            }
 
100
            if(hasMatch)
 
101
               _state.put(ptn, State.APPEARED);
 
102
            else
 
103
               _state.put(ptn, State.VANISHED);
 
104
         }
 
105
         catch(IOException e){
 
106
            Debug.error("Can't access "+ ptn +"\n" + e.getMessage()); 
 
107
         }
 
108
      }
 
109
 
 
110
   }
 
111
 
 
112
   protected void callChangeObserver(FindResults results) throws AWTException{
 
113
      for(Integer n : _changeOb.keySet()){
 
114
         List<Match> changes = new ArrayList<Match>();
 
115
         for(int i=0;i<results.size();i++){
 
116
            FindResult r = results.get(i);
 
117
            if( r.getW() * r.getH() >= n )
 
118
               changes.add(_region.toGlobalCoord(new Match(r)));
 
119
         }
 
120
         if(changes.size() > 0){
 
121
            ChangeEvent se = new ChangeEvent(changes, _region);
 
122
            SikuliEventObserver ob = _changeOb.get(n);
 
123
            ob.targetChanged(se);
 
124
         }
 
125
      }
 
126
   }
 
127
 
 
128
   protected int getMinChanges(){
 
129
      int min = Integer.MAX_VALUE;
 
130
      for(Integer n : _changeOb.keySet())
 
131
         if(n < min)
 
132
            min = n;
 
133
      return min;
 
134
   }
 
135
 
 
136
   protected void checkChanges(ScreenImage img){
 
137
      if(_lastImgMat == null){
 
138
         _lastImgMat = OpenCV.convertBufferedImageToMat(img.getImage());
 
139
         return;
 
140
      }
 
141
 
 
142
      FindInput fin = new FindInput();
 
143
      fin.setSource(_lastImgMat);
 
144
      Mat target = OpenCV.convertBufferedImageToMat(img.getImage());
 
145
      fin.setTarget(target);
 
146
      fin.setSimilarity(_minChanges);
 
147
 
 
148
      FindResults results = Vision.findChanges(fin);
 
149
      try{
 
150
         callChangeObserver(results);
 
151
      }
 
152
      catch(AWTException e){
 
153
         e.printStackTrace();
 
154
      }
 
155
 
 
156
      _lastImgMat = target;
96
157
   }
97
158
 
98
159
   public void update(ScreenImage img){
99
 
      byte[] data = OpenCV.convertBufferedImageToByteArray(img.getImage());
100
 
      SikuliEvent[] events = _update(_c_instance, data, img.w, img.h);
101
 
      if(events == null)
102
 
         return;
103
 
      for(SikuliEvent e : events){
104
 
         SikuliEventObserver ob = getObserverFromId(e.handler_id);
105
 
         e.x += _region.x;
106
 
         e.y += _region.y;
107
 
         switch(e.type){
108
 
            case APPEAR:
109
 
               ob.targetAppeared(new AppearEvent(e, _region));
110
 
               break;
111
 
            case VANISH:
112
 
               ob.targetVanished(new VanishEvent(e, _region));
113
 
               break;
114
 
            case CHANGE:
115
 
               ob.targetChanged(new ChangeEvent(e, _region));
116
 
               break;
117
 
         }
118
 
      }
 
160
      checkPatterns(img);
 
161
      if(_changeOb.size()>0)
 
162
         checkChanges(img);
119
163
   }
120
164
 
121
165
   protected void finalize() throws Throwable {
122
 
      dispose();
123
166
   }
124
167
 
125
168
 
126
169
   public void dispose(){
127
 
      destroy(_c_instance);
128
170
   }
129
171
 
130
 
   private native long createEventManager(); 
131
 
   private native void destroy(long sem_instance); 
132
 
   private native void addObserver(long sem_instance, 
133
 
                                   int evt_type, String target_image_filename,
134
 
                                   float similiarity,
135
 
                                   int handler_id, int x, int y, int w, int h); 
136
 
 
137
 
   private native SikuliEvent[] _update(long sem_instance, 
138
 
                                        byte[] screenImage, int w, int h);
139
 
 
140
172
}
141
173
 
142
174