← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/no-opencv-surf-module.patch/sikuli-script/src/main/native/imgdb.cpp

  • Committer: Package Import Robot
  • Author(s): Gilles Filippini
  • Date: 2012-06-25 12:33:23 UTC
  • mfrom: (4.1.8 sid)
  • Revision ID: package-import@ubuntu.com-20120625123323-p3aijrrzi3ohgste
Tags: 1.0~x~rc3.tesseract3-dfsg1-5
http://bugs.debian.org/678230
New patch no-opencv-surf-module.patch: 
Remove unsused portions of source code with dependency on the opencv
SURF module which isn't shipped anymore starting with opencv 2.4
because of being non-free (Closes: #678230)

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/no-opencv-surf-module.patch/sikuli-script/src/main/native/imgdb.cpp
 
1
/*
 
2
 * Copyright 2010-2011, Sikuli.org
 
3
 * Released under the MIT License.
 
4
 *
 
5
 */
 
6
 
 
7
#include "imgdb.h"
 
8
 
 
9
#ifdef WIN32
 
10
typedef INT32 int32_t;
 
11
#endif
 
12
 
 
13
void
 
14
ImageRecord::write(ostream& output_stream){   
 
15
   output_stream.write((char *) this, sizeof(class ImageRecord));
 
16
}
 
17
 
 
18
void
 
19
ImageRecord::read(istream& input_stream){
 
20
   input_stream.read((char *) this, sizeof(class ImageRecord));
 
21
}
 
22
 
 
23
Database::Database(){
 
24
}
 
25
 
 
26
 
 
27
vector<ImageRecord> 
 
28
Database::find(Mat image){
 
29
   vector<ImageRecord> top_matches;
 
30
   vector<ImageRecord> records;
 
31
   
 
32
   records = create_image_records_from_image(image);   
 
33
   
 
34
   for (vector<ImageRecord>::iterator r = records.begin();
 
35
        r != records.end(); ++r){
 
36
      
 
37
      //cout << endl << r->area << " : ";
 
38
      vector<ImageRecord> matches = find(*r);
 
39
      for (vector<ImageRecord>::iterator m = matches.begin();
 
40
           m != matches.end(); ++m){
 
41
         
 
42
         //cout << "(" << m->screenshot_id << ":" << m->id << ")";
 
43
      }
 
44
      
 
45
      if (!matches.empty())
 
46
         top_matches.push_back(matches[0]);
 
47
   }
 
48
   
 
49
   return top_matches;
 
50
   
 
51
}
 
52
 
 
53
vector<ImageRecord> 
 
54
Database::find(const char* filename){
 
55
   Mat image = imread(filename, 1);
 
56
   return find(image);
 
57
}
 
58
 
 
59
void
 
60
Database::insert(const ImageRecord& b){
 
61
   _image_records.push_back(b);
 
62
}
 
63
 
 
64
vector<ImageRecord>
 
65
Database::find(const ImageRecord& q){
 
66
   
 
67
   vector<ImageRecord> ret;
 
68
   
 
69
   vector<ImageRecord>::iterator it = _image_records.begin();
 
70
   for (; it != _image_records.end(); ++it){
 
71
      
 
72
      ImageRecord& p = *it;
 
73
      
 
74
      if (abs(q.area - it->area) > 10)
 
75
         continue;
 
76
      
 
77
      if (abs(q.height - it->height) > 5)
 
78
         continue;
 
79
      
 
80
      if (abs(q.width - it->width) > 5)
 
81
         continue;
 
82
      
 
83
      
 
84
      float s = 1.0;
 
85
      
 
86
      
 
87
      if (abs(q.mr - it->mr) > 10)
 
88
         continue;
 
89
      
 
90
      if (abs(q.mg - it->mg) > 10)
 
91
         continue;
 
92
      
 
93
      if (abs(q.mb - it->mb) > 10)
 
94
         continue;
 
95
      
 
96
      //      cout << it->id << ": ";
 
97
      //      cout << q.mr*s << " " << q.mg*s << " " << q.mb*s << "<->";
 
98
      //      cout << p.mr << " " << p.mg << " " << p.mb << endl;      
 
99
      
 
100
      ret.push_back(*it);       
 
101
      
 
102
      return ret;
 
103
   }
 
104
   
 
105
   return ret;
 
106
   
 
107
}
 
108
 
 
109
static int image_record_id = 0;
 
110
static int word_id = 0;
 
111
 
 
112
#include <fstream>
 
113
 
 
114
void
 
115
Database::insert_file(const char* filename, int screenshot_id){
 
116
   
 
117
   Mat image = imread(filename, 1);
 
118
   
 
119
   
 
120
   char buf[200];
 
121
//   sprintf(buf,"%s.ui",filename);
 
122
//   std::ofstream fout(buf);
 
123
   
 
124
   sprintf(buf,"%s.ui",filename);
 
125
   std::ofstream fout_loc(buf);
 
126
   
 
127
   vector<Blob> text_blobs, image_blobs;
 
128
   cvgui::segmentScreenshot(image, text_blobs, image_blobs);  
 
129
   
 
130
   
 
131
   vector<ImageRecord> records;
 
132
   records = create_image_records_from_blobs(image, image_blobs);
 
133
   
 
134
   for (int i = 0; i < image_blobs.size(); ++i){
 
135
      
 
136
      
 
137
      Blob& b = image_blobs[i];
 
138
      ImageRecord& r = records[i];
 
139
      
 
140
      // ignore small elements
 
141
      if (r.width < 15 || r.height < 15)
 
142
         continue;      
 
143
      
 
144
      vector<ImageRecord> matches;
 
145
      matches = find(r);
 
146
      
 
147
      if (matches.empty()){
 
148
         
 
149
         r.id = word_id;
 
150
         
 
151
         insert(r);
 
152
#if 0                  
 
153
         char buf[80];
 
154
         Mat part(image, b.bound);
 
155
         sprintf(buf, "research/result/ir-%d-%d.png",word_id,image_record_id);
 
156
         imwrite(buf, part);
 
157
#endif         
 
158
         word_id++;
 
159
         
 
160
      }else{
 
161
         
 
162
         r.id = matches[0].id;
 
163
      }
 
164
      
 
165
      //fout << "ui" << r.id << " ";
 
166
      
 
167
      
 
168
      
 
169
      fout_loc << r.x << " " << r.y << " " << r.width << " " << r.height << " ";
 
170
      fout_loc << "ui" << r.id;
 
171
      fout_loc << endl;
 
172
   }
 
173
   
 
174
   //fout << endl;
 
175
   //fout.close();
 
176
   fout_loc.close();
 
177
} 
 
178
 
 
179
vector<ImageRecord>
 
180
Database::create_image_records_from_image(Mat image){
 
181
   vector<Blob> text_blobs;
 
182
   vector<Blob> image_blobs;
 
183
   
 
184
   cvgui::segmentScreenshot(image, text_blobs, image_blobs);     
 
185
   return create_image_records_from_blobs(image, image_blobs);
 
186
}
 
187
 
 
188
 
 
189
 
 
190
vector<ImageRecord>
 
191
Database::create_image_records_from_imagefile(const char* filename){
 
192
   Mat image = imread(filename, 1);
 
193
   return create_image_records_from_image(image);
 
194
}
 
195
 
 
196
 
 
197
vector<ImageRecord>
 
198
Database::create_image_records_from_blobs(const Mat& src, const vector<Blob> image_blobs){
 
199
   
 
200
   
 
201
   vector<ImageRecord> ret;
 
202
   
 
203
   
 
204
   for (vector<Blob>::const_iterator b = image_blobs.begin();
 
205
        b != image_blobs.end(); ++b){
 
206
      
 
207
      Rect r = *b;      
 
208
      Mat part(src, r);
 
209
      
 
210
      
 
211
      ImageRecord ib;
 
212
      ib.x = r.x;
 
213
      ib.y = r.y;
 
214
      ib.width = r.width;
 
215
      ib.height = r.height;
 
216
      ib.area = b->area;
 
217
      
 
218
      
 
219
      Scalar mean, stddev;
 
220
      meanStdDev(part, mean, stddev, Mat());
 
221
      
 
222
      ib.mr = mean[0];
 
223
      ib.mg = mean[1];
 
224
      ib.mb = mean[2];
 
225
      
 
226
      ret.push_back(ib);
 
227
      
 
228
      image_record_id++;      
 
229
   }
 
230
   
 
231
   return ret;
 
232
}
 
233
 
 
234
 
 
235
 
 
236
 
 
237
 
 
238
 
 
239
//vector<ImageRecord>
 
240
//ImageRecord::create_from_imagefile(const char* filename){
 
241
//   
 
242
//   vector<Blob> text_blobs;
 
243
//   vector<Blob> image_blobs;
 
244
//  
 
245
//   Mat image = imread(filename, 1);
 
246
//   cvgui::segmentScreenshot(image, text_blobs, image_blobs);  
 
247
//
 
248
//   return ImageRecord::create_from_blobs(image, image_blobs);
 
249
//}
 
250
//
 
251
//
 
252
//vector<ImageRecord>
 
253
//ImageRecord::create_from_blobs(const Mat& src, const vector<Blob> image_blobs){
 
254
//   
 
255
//   
 
256
//   vector<ImageRecord> ret;
 
257
//   
 
258
//   
 
259
//   for (vector<Blob>::const_iterator b = image_blobs.begin();
 
260
//        b != image_blobs.end(); ++b){
 
261
//      
 
262
//      
 
263
//      
 
264
//      Rect r = b->bound;
 
265
//      
 
266
//      Mat part(src, r);
 
267
//      
 
268
//      //char buf[80];
 
269
//      //sprintf(buf, "research/result/ir-%d.png",image_record_id);
 
270
//      //imwrite(buf, part);
 
271
//      
 
272
//      
 
273
//      ImageRecord ib;
 
274
//      ib.x = r.x;
 
275
//      ib.y = r.y;
 
276
//      ib.width = r.width;
 
277
//      ib.height = r.height;
 
278
//      ib.area = b->area;
 
279
//
 
280
//      ret.push_back(ib);
 
281
//      
 
282
//      //image_record_id++;
 
283
//   }
 
284
//   
 
285
//   return ret;
 
286
//}
 
287
 
 
288
void
 
289
Database::write(ostream& stream){   
 
290
   
 
291
   int32_t num_records = _image_records.size();
 
292
   stream.write((char *)(&num_records), sizeof(int32_t));
 
293
   
 
294
   for (int jj = 0; jj < num_records; ++jj) {
 
295
      _image_records[jj].write(stream);
 
296
   }
 
297
}
 
298
 
 
299
void
 
300
Database::read(istream& stream){
 
301
   int32_t num_records;
 
302
   stream.read((char *)(&num_records), sizeof(int32_t));
 
303
   
 
304
   for (int jj = 0; jj < num_records; ++jj) {
 
305
      ImageRecord rec;
 
306
      rec.read(stream);
 
307
      _image_records.push_back(rec);
 
308
   }
 
309
}
 
310
 
 
311