Bitmap.cpp
Go to the documentation of this file.
1#include "Bitmap.h"
2
3#include <algorithm>
4#include <fstream>
5#include <iomanip>
6#include <iostream>
7#include <sstream>
8
9#include "Grid.h"
10#include <GfxTL/VectorXD.h>
11#include <MiscLib/Performance.h>
12using namespace MiscLib;
13extern MiscLib::performance_t totalTime_components;
14
15void
16DilateSquare(const MiscLib::Vector<char>& bitmap,
17 size_t uextent,
18 size_t vextent,
19 bool uwrap,
20 bool vwrap,
21 MiscLib::Vector<char>* dilated)
22{
23 // first pixel is special
24 (*dilated)[0] = bitmap[0] || bitmap[1] || bitmap[uextent] || bitmap[uextent + 1];
25 if (vwrap)
26 (*dilated)[0] =
27 (*dilated)[0] || bitmap[(vextent - 1) * uextent] || bitmap[(vextent - 1) * uextent + 1];
28 if (uwrap)
29 (*dilated)[0] = (*dilated)[0] || bitmap[uextent - 1] || bitmap[2 * uextent - 1];
30 if (vwrap && uwrap)
31 (*dilated)[0] = (*dilated)[0] || bitmap[(vextent - 1) * uextent + uextent - 1];
32 // first row is special
33 if (!vwrap)
34 {
35 for (size_t i = 1; i < uextent - 1; ++i)
36 {
37 (*dilated)[i] = bitmap[i - 1] || bitmap[i] || bitmap[i + 1] ||
38 bitmap[uextent + i - 1] || bitmap[uextent + i] ||
39 bitmap[uextent + i + 1];
40 }
41 }
42 else
43 {
44 for (size_t i = 1; i < uextent - 1; ++i)
45 {
46 (*dilated)[i] = bitmap[i - 1] || bitmap[i] || bitmap[i + 1] ||
47 bitmap[uextent + i - 1] || bitmap[uextent + i] ||
48 bitmap[uextent + i + 1] || bitmap[(vextent - 1) * uextent + i - 1] ||
49 bitmap[(vextent - 1) * uextent + i] ||
50 bitmap[(vextent - 1) * uextent + i + 1];
51 }
52 }
53 // last pixel of first row is special
54 (*dilated)[uextent - 1] = bitmap[uextent - 1] || bitmap[uextent - 2] ||
55 bitmap[2 * uextent - 1] || bitmap[2 * uextent - 2];
56 if (vwrap)
57 (*dilated)[uextent - 1] = (*dilated)[uextent - 1] || bitmap[vextent * uextent - 1] ||
58 bitmap[vextent * uextent - 2];
59 if (uwrap)
60 (*dilated)[uextent - 1] = (*dilated)[uextent - 1] || bitmap[uextent] || bitmap[0];
61 if (uwrap && vwrap)
62 (*dilated)[uextent - 1] = (*dilated)[uextent - 1] || bitmap[(vextent - 1) * uextent];
63 size_t row = 0, prevRow, nextRow = uextent;
64 for (size_t j = 1; j < vextent - 1; ++j)
65 {
66 prevRow = row;
67 row = nextRow;
68 nextRow = row + uextent;
69 // first pixel in row is special
70 (*dilated)[row] = bitmap[prevRow] || bitmap[prevRow + 1] || bitmap[row] ||
71 bitmap[row + 1] || bitmap[nextRow] || bitmap[nextRow + 1];
72 if (uwrap)
73 (*dilated)[row] = (*dilated)[row] || bitmap[row - 1] || bitmap[nextRow - 1] ||
74 bitmap[nextRow + uextent - 1];
75 for (size_t i = 1; i < uextent - 1; ++i)
76 {
77 (*dilated)[row + i] =
78 bitmap[prevRow + i - 1] || bitmap[prevRow + i] || bitmap[prevRow + i + 1] ||
79 bitmap[row + i - 1] || bitmap[row + i] || bitmap[row + i + 1] ||
80 bitmap[nextRow + i - 1] || bitmap[nextRow + i] || bitmap[nextRow + i + 1];
81 }
82 // last pixel in row is special
83 (*dilated)[row + uextent - 1] =
84 bitmap[prevRow + uextent - 2] || bitmap[prevRow + uextent - 1] ||
85 bitmap[row + uextent - 2] || bitmap[row + uextent - 1] ||
86 bitmap[nextRow + uextent - 2] || bitmap[nextRow + uextent - 1];
87 if (uwrap)
88 (*dilated)[row + uextent - 1] =
89 (*dilated)[row + uextent - 1] || bitmap[prevRow] || bitmap[row] || bitmap[nextRow];
90 }
91 // first pixel of last row is special
92 (*dilated)[(vextent - 1) * uextent] =
93 bitmap[(vextent - 1) * uextent] || bitmap[(vextent - 1) * uextent + 1] ||
94 bitmap[(vextent - 2) * uextent] || bitmap[(vextent - 2) * uextent + 1];
95 if (vwrap)
96 (*dilated)[(vextent - 1) * uextent] =
97 (*dilated)[(vextent - 1) * uextent] || bitmap[0] || bitmap[1];
98 if (uwrap)
99 (*dilated)[(vextent - 1) * uextent] = (*dilated)[(vextent - 1) * uextent] ||
100 bitmap[vextent * uextent - 1] ||
101 bitmap[(vextent - 1) * uextent - 1];
102 if (vwrap && uwrap)
103 (*dilated)[(vextent - 1) * uextent] =
104 (*dilated)[(vextent - 1) * uextent] || bitmap[uextent - 1];
105 // last row is special
106 if (!vwrap)
107 {
108 for (size_t i = 1; i < uextent - 1; ++i)
109 {
110 (*dilated)[(vextent - 1) * uextent + i] =
111 bitmap[(vextent - 1) * uextent + i] || bitmap[(vextent - 1) * uextent + i - 1] ||
112 bitmap[(vextent - 1) * uextent + i + 1] || bitmap[(vextent - 2) * uextent + i] ||
113 bitmap[(vextent - 2) * uextent + i - 1] || bitmap[(vextent - 2) * uextent + i + 1];
114 }
115 }
116 else
117 {
118 for (size_t i = 1; i < uextent - 1; ++i)
119 {
120 (*dilated)[(vextent - 1) * uextent + i] =
121 bitmap[(vextent - 1) * uextent + i] || bitmap[(vextent - 1) * uextent + i - 1] ||
122 bitmap[(vextent - 1) * uextent + i + 1] || bitmap[(vextent - 2) * uextent + i] ||
123 bitmap[(vextent - 2) * uextent + i - 1] ||
124 bitmap[(vextent - 2) * uextent + i + 1] || bitmap[i - 1] || bitmap[i] ||
125 bitmap[i + 1];
126 }
127 }
128 // last pixel
129 (*dilated)[bitmap.size() - 1] = bitmap[bitmap.size() - 1] || bitmap[bitmap.size() - 2] ||
130 bitmap[bitmap.size() - uextent - 1] ||
131 bitmap[bitmap.size() - uextent - 2];
132 if (vwrap)
133 (*dilated)[bitmap.size() - 1] =
134 (*dilated)[bitmap.size() - 1] || bitmap[uextent - 1] || bitmap[uextent - 2];
135 if (uwrap)
136 (*dilated)[bitmap.size() - 1] = (*dilated)[bitmap.size() - 1] ||
137 bitmap[bitmap.size() - uextent] ||
138 bitmap[bitmap.size() - 2 * uextent];
139 if (uwrap && vwrap)
140 (*dilated)[bitmap.size() - 1] = (*dilated)[bitmap.size() - 1] || bitmap[0];
141}
142
143void
144DilateCross(const MiscLib::Vector<char>& bitmap,
145 size_t uextent,
146 size_t vextent,
147 bool uwrap,
148 bool vwrap,
149 MiscLib::Vector<char>* dilated)
150{
151 // first pixel is special
152 (*dilated)[0] = bitmap[0] || bitmap[1] || bitmap[uextent];
153 if (vwrap)
154 (*dilated)[0] = (*dilated)[0] || bitmap[(vextent - 1) * uextent];
155 if (uwrap)
156 {
157 (*dilated)[0] = (*dilated)[0] || bitmap[uextent - 1];
158 }
159 // first row is special
160 if (!vwrap)
161 {
162 for (size_t i = 1; i < uextent - 1; ++i)
163 {
164 (*dilated)[i] = bitmap[i - 1] || bitmap[i] || bitmap[i + 1] || bitmap[uextent + i];
165 }
166 }
167 else
168 {
169 for (size_t i = 1; i < uextent - 1; ++i)
170 {
171 (*dilated)[i] = bitmap[i - 1] || bitmap[i] || bitmap[i + 1] || bitmap[uextent + i] ||
172 bitmap[(vextent - 1) * uextent + i];
173 }
174 }
175 // last pixel of first row is special
176 (*dilated)[uextent - 1] = bitmap[uextent - 1] || bitmap[uextent - 2] || bitmap[2 * uextent - 1];
177 if (vwrap)
178 (*dilated)[uextent - 1] = (*dilated)[uextent - 1] || bitmap[vextent * uextent - 1];
179 if (uwrap)
180 {
181 (*dilated)[uextent - 1] = (*dilated)[uextent - 1] || bitmap[0];
182 }
183 size_t row = 0, prevRow, nextRow = uextent;
184 for (size_t j = 1; j < vextent - 1; ++j)
185 {
186 prevRow = row;
187 row = nextRow;
188 nextRow = row + uextent;
189 // first pixel in row is special
190 (*dilated)[row] = bitmap[prevRow] || bitmap[row] || bitmap[row + 1] || bitmap[nextRow];
191 if (uwrap)
192 {
193 (*dilated)[row] = (*dilated)[row] || bitmap[nextRow - 1];
194 }
195 for (size_t i = 1; i < uextent - 1; ++i)
196 {
197 (*dilated)[row + i] = bitmap[prevRow + i] || bitmap[row + i - 1] || bitmap[row + i] ||
198 bitmap[row + i + 1] || bitmap[nextRow + i];
199 }
200 // last pixel in row is special
201 (*dilated)[row + uextent - 1] = bitmap[prevRow + uextent - 1] ||
202 bitmap[row + uextent - 2] || bitmap[row + uextent - 1] ||
203 bitmap[nextRow + uextent - 1];
204 if (uwrap)
205 (*dilated)[row + uextent - 1] = (*dilated)[row + uextent - 1] || bitmap[row];
206 }
207 // first pixel of last row is special
208 (*dilated)[(vextent - 1) * uextent] = bitmap[(vextent - 1) * uextent] ||
209 bitmap[(vextent - 1) * uextent + 1] ||
210 bitmap[(vextent - 2) * uextent];
211 if (vwrap)
212 (*dilated)[(vextent - 1) * uextent] = (*dilated)[(vextent - 1) * uextent] || bitmap[0];
213 if (uwrap)
214 (*dilated)[(vextent - 1) * uextent] =
215 (*dilated)[(vextent - 1) * uextent] || bitmap[vextent * uextent - 1];
216 // last row is special
217 if (!vwrap)
218 {
219 for (size_t i = 1; i < uextent - 1; ++i)
220 {
221 (*dilated)[(vextent - 1) * uextent + i] =
222 bitmap[(vextent - 1) * uextent + i] || bitmap[(vextent - 1) * uextent + i - 1] ||
223 bitmap[(vextent - 1) * uextent + i + 1] || bitmap[(vextent - 2) * uextent + i];
224 }
225 }
226 else
227 {
228 for (size_t i = 1; i < uextent - 1; ++i)
229 {
230 (*dilated)[(vextent - 1) * uextent + i] =
231 bitmap[(vextent - 1) * uextent + i] || bitmap[(vextent - 1) * uextent + i - 1] ||
232 bitmap[(vextent - 1) * uextent + i + 1] || bitmap[(vextent - 2) * uextent + i] ||
233 bitmap[i];
234 }
235 }
236 // last pixel
237 (*dilated)[bitmap.size() - 1] = bitmap[bitmap.size() - 1] || bitmap[bitmap.size() - 2] ||
238 bitmap[bitmap.size() - uextent - 1];
239 if (vwrap)
240 (*dilated)[bitmap.size() - 1] = (*dilated)[bitmap.size() - 1] || bitmap[uextent - 1];
241 if (uwrap)
242 (*dilated)[bitmap.size() - 1] =
243 (*dilated)[bitmap.size() - 1] || bitmap[bitmap.size() - uextent];
244}
245
246void
247ErodeSquare(const MiscLib::Vector<char>& bitmap,
248 size_t uextent,
249 size_t vextent,
250 bool uwrap,
251 bool vwrap,
252 MiscLib::Vector<char>* eroded)
253{
254 // first pixel is special
255 (*eroded)[0] = /*bitmap[0] && bitmap[1] &&
256 bitmap[uextent] && bitmap[uextent + 1]*/
257 false;
258 //if(vwrap)
259 // (*eroded)[0] = (*eroded)[0] &&
260 // bitmap[(vextent - 1) * uextent] &&
261 // bitmap[(vextent - 1) * uextent + 1];
262 //if(uwrap)
263 // (*eroded)[0] = (*eroded)[0] && bitmap[uextent - 1]
264 // && bitmap[2 * uextent - 1];
265 if (vwrap && uwrap)
266 {
267 (*eroded)[0] = bitmap[0] && bitmap[1] && bitmap[uextent] && bitmap[uextent + 1] &&
268 bitmap[(vextent - 1) * uextent] && bitmap[(vextent - 1) * uextent + 1] &&
269 bitmap[uextent - 1] && bitmap[2 * uextent - 1] &&
270 bitmap[(vextent - 1) * uextent + uextent - 1];
271 //(*eroded)[0] = (*eroded)[0] &&
272 // bitmap[(vextent - 1) * uextent + uextent - 1];
273 }
274 // first row is special
275 if (!vwrap)
276 {
277 for (size_t i = 1; i < uextent - 1; ++i)
278 {
279 (*eroded)[i] = /*bitmap[i - 1] && bitmap[i] && bitmap[i + 1] &&
280 bitmap[uextent + i - 1] && bitmap[uextent + i] &&
281 bitmap[uextent + i + 1];*/
282 false;
283 }
284 }
285 else
286 {
287 for (size_t i = 1; i < uextent - 1; ++i)
288 {
289 (*eroded)[i] = bitmap[i - 1] && bitmap[i] && bitmap[i + 1] && bitmap[uextent + i - 1] &&
290 bitmap[uextent + i] && bitmap[uextent + i + 1] &&
291 bitmap[(vextent - 1) * uextent + i - 1] &&
292 bitmap[(vextent - 1) * uextent + i] &&
293 bitmap[(vextent - 1) * uextent + i + 1];
294 }
295 }
296 // last pixel of first row is special
297 (*eroded)[uextent - 1] = /*bitmap[uextent - 1] && bitmap[uextent - 2] &&
298 bitmap[2 * uextent - 1] && bitmap[2 * uextent - 2]*/
299 false;
300 //if(vwrap)
301 // (*eroded)[uextent - 1] = (*eroded)[uextent - 1] &&
302 // bitmap[vextent * uextent - 1] &&
303 // bitmap[vextent * uextent - 2];
304 //if(uwrap)
305 // (*eroded)[uextent - 1] = (*eroded)[uextent - 1] &&
306 // bitmap[uextent] && bitmap[0];
307 if (uwrap && vwrap)
308 {
309 (*eroded)[uextent - 1] = bitmap[uextent - 1] && bitmap[uextent - 2] &&
310 bitmap[2 * uextent - 1] && bitmap[2 * uextent - 2] &&
311 bitmap[vextent * uextent - 1] && bitmap[vextent * uextent - 2] &&
312 bitmap[uextent] && bitmap[0] && bitmap[(vextent - 1) * uextent];
313 }
314 size_t row = 0, prevRow, nextRow = uextent;
315 for (size_t j = 1; j < vextent - 1; ++j)
316 {
317 prevRow = row;
318 row = nextRow;
319 nextRow = row + uextent;
320 // first pixel in row is special
321 (*eroded)[row] = /*bitmap[prevRow] && bitmap[prevRow + 1] &&
322 bitmap[row] && bitmap[row + 1] && bitmap[nextRow] &&
323 bitmap[nextRow + 1]*/
324 false;
325 if (uwrap)
326 {
327 (*eroded)[row] = bitmap[prevRow] && bitmap[prevRow + 1] && bitmap[row] &&
328 bitmap[row + 1] && bitmap[nextRow] && bitmap[nextRow + 1] &&
329 bitmap[row - 1] && bitmap[nextRow - 1] &&
330 bitmap[nextRow + uextent - 1];
331 }
332 for (size_t i = 1; i < uextent - 1; ++i)
333 {
334 (*eroded)[row + i] =
335 bitmap[prevRow + i - 1] && bitmap[prevRow + i] && bitmap[prevRow + i + 1] &&
336 bitmap[row + i - 1] && bitmap[row + i] && bitmap[row + i + 1] &&
337 bitmap[nextRow + i - 1] && bitmap[nextRow + i] && bitmap[nextRow + i + 1];
338 }
339 // last pixel in row is special
340 (*eroded)[row + uextent - 1] = /*bitmap[prevRow + uextent - 2] &&
341 bitmap[prevRow + uextent - 1] &&
342 bitmap[row + uextent - 2] && bitmap[row + uextent - 1] &&
343 bitmap[nextRow + uextent - 2] && bitmap[nextRow + uextent - 1]*/
344 false;
345 if (uwrap)
346 {
347 (*eroded)[row + uextent - 1] =
348 bitmap[prevRow + uextent - 2] && bitmap[prevRow + uextent - 1] &&
349 bitmap[row + uextent - 2] && bitmap[row + uextent - 1] &&
350 bitmap[nextRow + uextent - 2] && bitmap[nextRow + uextent - 1] && bitmap[prevRow] &&
351 bitmap[row] && bitmap[nextRow];
352 }
353 }
354 // first pixel of last row is special
355 (*eroded)[(vextent - 1) * uextent] = /*bitmap[(vextent - 1) * uextent] &&
356 bitmap[(vextent - 1) * uextent + 1] &&
357 bitmap[(vextent - 2) * uextent] && bitmap[(vextent - 2) * uextent + 1]*/
358 false;
359 //if(vwrap)
360 // (*eroded)[(vextent - 1) * uextent] =
361 // (*eroded)[(vextent - 1) * uextent] && bitmap[0] && bitmap[1];
362 //if(uwrap)
363 // (*eroded)[(vextent - 1) * uextent] =
364 // (*eroded)[(vextent - 1) * uextent] &&
365 // bitmap[vextent * uextent - 1] &&
366 // bitmap[(vextent - 1) * uextent - 1];
367 if (vwrap && uwrap)
368 {
369 (*eroded)[(vextent - 1) * uextent] =
370 bitmap[(vextent - 1) * uextent] && bitmap[(vextent - 1) * uextent + 1] &&
371 bitmap[(vextent - 2) * uextent] && bitmap[(vextent - 2) * uextent + 1] && bitmap[0] &&
372 bitmap[1] && bitmap[vextent * uextent - 1] && bitmap[(vextent - 1) * uextent - 1] &&
373 bitmap[uextent - 1];
374 }
375 // last row is special
376 if (!vwrap)
377 {
378 for (size_t i = 1; i < uextent - 1; ++i)
379 {
380 (*eroded)[(vextent - 1) * uextent + i] = false
381 /*bitmap[(vextent - 1) * uextent + i] &&
382 bitmap[(vextent - 1) * uextent + i - 1] &&
383 bitmap[(vextent - 1) * uextent + i + 1] &&
384 bitmap[(vextent - 2) * uextent + i] &&
385 bitmap[(vextent - 2) * uextent + i - 1] &&
386 bitmap[(vextent - 2) * uextent + i + 1]*/
387 ;
388 }
389 }
390 else
391 {
392 for (size_t i = 1; i < uextent - 1; ++i)
393 {
394 (*eroded)[(vextent - 1) * uextent + i] =
395 bitmap[(vextent - 1) * uextent + i] && bitmap[(vextent - 1) * uextent + i - 1] &&
396 bitmap[(vextent - 1) * uextent + i + 1] && bitmap[(vextent - 2) * uextent + i] &&
397 bitmap[(vextent - 2) * uextent + i - 1] &&
398 bitmap[(vextent - 2) * uextent + i + 1] && bitmap[i - 1] && bitmap[i] &&
399 bitmap[i + 1];
400 }
401 }
402 // last pixel
403 (*eroded)[bitmap.size() - 1] = false /*bitmap[bitmap.size() - 1] &&
404 bitmap[bitmap.size() - 2] && bitmap[bitmap.size() - uextent - 1] &&
405 bitmap[bitmap.size() - uextent - 2]*/
406 ;
407 //if(vwrap)
408 // (*eroded)[bitmap.size() - 1] = (*eroded)[bitmap.size() - 1] &&
409 // bitmap[uextent - 1] && bitmap[uextent - 2];
410 //if(uwrap)
411 // (*eroded)[bitmap.size() - 1] = (*eroded)[bitmap.size() - 1] &&
412 // bitmap[bitmap.size() - uextent] &&
413 // bitmap[bitmap.size() - 2 * uextent];
414 if (uwrap && vwrap)
415 {
416 (*eroded)[bitmap.size() - 1] = bitmap[bitmap.size() - 1] && bitmap[bitmap.size() - 2] &&
417 bitmap[bitmap.size() - uextent - 1] &&
418 bitmap[bitmap.size() - uextent - 2] && bitmap[uextent - 1] &&
419 bitmap[uextent - 2] && bitmap[bitmap.size() - uextent] &&
420 bitmap[bitmap.size() - 2 * uextent] && bitmap[0];
421 }
422}
423
424void
425ErodeCross(const MiscLib::Vector<char>& bitmap,
426 size_t uextent,
427 size_t vextent,
428 bool uwrap,
429 bool vwrap,
430 MiscLib::Vector<char>* eroded)
431{
432 // first pixel is special
433 (*eroded)[0] = bitmap[0] && bitmap[1] && bitmap[uextent];
434 if (vwrap)
435 (*eroded)[0] = (*eroded)[0] && bitmap[(vextent - 1) * uextent];
436 if (uwrap)
437 {
438 (*eroded)[0] = (*eroded)[0] && bitmap[uextent - 1];
439 }
440 // first row is special
441 if (!vwrap)
442 {
443 for (size_t i = 1; i < uextent - 1; ++i)
444 {
445 (*eroded)[i] = bitmap[i - 1] && bitmap[i] && bitmap[i + 1] && bitmap[uextent + i];
446 }
447 }
448 else
449 {
450 for (size_t i = 1; i < uextent - 1; ++i)
451 {
452 (*eroded)[i] = bitmap[i - 1] && bitmap[i] && bitmap[i + 1] && bitmap[uextent + i] &&
453 bitmap[(vextent - 1) * uextent + i];
454 }
455 }
456 // last pixel of first row is special
457 (*eroded)[uextent - 1] = bitmap[uextent - 1] && bitmap[uextent - 2] && bitmap[2 * uextent - 1];
458 if (vwrap)
459 (*eroded)[uextent - 1] = (*eroded)[uextent - 1] && bitmap[vextent * uextent - 1];
460 if (uwrap)
461 {
462 (*eroded)[uextent - 1] = (*eroded)[uextent - 1] && bitmap[0];
463 }
464 size_t row = 0, prevRow, nextRow = uextent;
465 for (size_t j = 1; j < vextent - 1; ++j)
466 {
467 prevRow = row;
468 row = nextRow;
469 nextRow = row + uextent;
470 // first pixel in row is special
471 (*eroded)[row] = bitmap[prevRow] && bitmap[row] && bitmap[row + 1] && bitmap[nextRow];
472 if (uwrap)
473 {
474 (*eroded)[row] = (*eroded)[row] && bitmap[nextRow - 1];
475 }
476 for (size_t i = 1; i < uextent - 1; ++i)
477 {
478 (*eroded)[row + i] = bitmap[prevRow + i] && bitmap[row + i - 1] && bitmap[row + i] &&
479 bitmap[row + i + 1] && bitmap[nextRow + i];
480 }
481 // last pixel in row is special
482 (*eroded)[row + uextent - 1] = bitmap[prevRow + uextent - 1] && bitmap[row + uextent - 2] &&
483 bitmap[row + uextent - 1] && bitmap[nextRow + uextent - 1];
484 if (uwrap)
485 (*eroded)[row + uextent - 1] = (*eroded)[row + uextent - 1] && bitmap[row];
486 }
487 // first pixel of last row is special
488 (*eroded)[(vextent - 1) * uextent] = bitmap[(vextent - 1) * uextent] &&
489 bitmap[(vextent - 1) * uextent + 1] &&
490 bitmap[(vextent - 2) * uextent];
491 if (vwrap)
492 (*eroded)[(vextent - 1) * uextent] = (*eroded)[(vextent - 1) * uextent] && bitmap[0];
493 if (uwrap)
494 (*eroded)[(vextent - 1) * uextent] =
495 (*eroded)[(vextent - 1) * uextent] && bitmap[vextent * uextent - 1];
496 // last row is special
497 if (!vwrap)
498 {
499 for (size_t i = 1; i < uextent - 1; ++i)
500 {
501 (*eroded)[(vextent - 1) * uextent + i] =
502 bitmap[(vextent - 1) * uextent + i] && bitmap[(vextent - 1) * uextent + i - 1] &&
503 bitmap[(vextent - 1) * uextent + i + 1] && bitmap[(vextent - 2) * uextent + i];
504 }
505 }
506 else
507 {
508 for (size_t i = 1; i < uextent - 1; ++i)
509 {
510 (*eroded)[(vextent - 1) * uextent + i] =
511 bitmap[(vextent - 1) * uextent + i] && bitmap[(vextent - 1) * uextent + i - 1] &&
512 bitmap[(vextent - 1) * uextent + i + 1] && bitmap[(vextent - 2) * uextent + i] &&
513 bitmap[i];
514 }
515 }
516 // last pixel
517 (*eroded)[bitmap.size() - 1] = bitmap[bitmap.size() - 1] && bitmap[bitmap.size() - 2] &&
518 bitmap[bitmap.size() - uextent - 1];
519 if (vwrap)
520 (*eroded)[bitmap.size() - 1] = (*eroded)[bitmap.size() - 1] && bitmap[uextent - 1];
521 if (uwrap)
522 (*eroded)[bitmap.size() - 1] =
523 (*eroded)[bitmap.size() - 1] && bitmap[bitmap.size() - uextent];
524}
525
526void
527PreWrappedComponents(const MiscLib::Vector<char>& bitmap,
528 size_t uextent,
529 size_t vextent,
530 MiscLib::Vector<int>* preWrappedComponentsImg,
531 MiscLib::Vector<int>* relabelComponentsImg,
532 const MiscLib::Vector<std::pair<int, size_t>>& inLabels,
533 MiscLib::Vector<std::pair<int, size_t>>* labels)
534{
535 MiscLib::Vector<std::pair<int, size_t>> tempLabels(inLabels);
536 tempLabels.reserve(bitmap.size() / 2 + 1); // this is the maximum of possible tempLabels
537 if (!tempLabels.size())
538 {
539 tempLabels.push_back(std::make_pair(0, size_t(0)));
540 }
541 int curLabel = tempLabels.size() - 1;
542 size_t prevRow, row = 0, nextRow = uextent;
543 for (size_t j = 1; j < vextent - 1; ++j)
544 {
545 prevRow = row;
546 row = nextRow;
547 nextRow = row + uextent;
548 for (size_t i = 1; i < uextent - 1; ++i)
549 {
550 if (!bitmap[row + i])
551 {
552 (*preWrappedComponentsImg)[row + i] = 0;
553 ++tempLabels[0].second;
554 continue;
555 }
556 // get neighborhood
557 int n[8];
558 n[0] = (*preWrappedComponentsImg)[prevRow + i - 1];
559 n[1] = (*preWrappedComponentsImg)[prevRow + i];
560 n[2] = (*preWrappedComponentsImg)[prevRow + i + 1];
561 n[3] = (*preWrappedComponentsImg)[row + i - 1];
562 n[4] = (*preWrappedComponentsImg)[row + i + 1];
563 n[5] = (*preWrappedComponentsImg)[nextRow + i - 1];
564 n[6] = (*preWrappedComponentsImg)[nextRow + i];
565 n[7] = (*preWrappedComponentsImg)[nextRow + i + 1];
566 (*preWrappedComponentsImg)[row + i] = Label(n, 8, &curLabel, &tempLabels);
567 }
568 }
569
570 // reduce the tempLabels
571 for (size_t i = tempLabels.size() - 1; i > 0; --i)
572 {
573 tempLabels[i].first = ReduceLabel(i, tempLabels);
574 }
575 MiscLib::Vector<int> condensed(tempLabels.size());
576 labels->clear();
577 labels->reserve(condensed.size());
578 int count = 0;
579 for (size_t i = 0; i < tempLabels.size(); ++i)
580 if (i == (size_t)tempLabels[i].first)
581 {
582 labels->push_back(std::make_pair(count, tempLabels[i].second));
583 condensed[i] = count;
584 ++count;
585 }
586 else
587 (*labels)[condensed[tempLabels[i].first]].second += tempLabels[i].second;
588 // set new component ids
589 for (size_t i = 0; i < preWrappedComponentsImg->size(); ++i)
590 (*preWrappedComponentsImg)[i] = condensed[tempLabels[(*preWrappedComponentsImg)[i]].first];
591 for (size_t i = 0; i < relabelComponentsImg->size(); ++i)
592 (*relabelComponentsImg)[i] = condensed[tempLabels[(*relabelComponentsImg)[i]].first];
593}
594
595void
596Components(const MiscLib::Vector<char>& bitmap,
597 size_t uextent,
598 size_t vextent,
599 bool uwrap,
600 bool vwrap,
601 MiscLib::Vector<int>* componentsImg,
602 MiscLib::Vector<std::pair<int, size_t>>* labels)
603{
604 componentsImg->resize(uextent * vextent);
605 MiscLib::Vector<std::pair<int, size_t>> tempLabels;
606 tempLabels.reserve(componentsImg->size() / 2 + 1); // this is the maximum of possible tempLabels
607 tempLabels.push_back(std::make_pair(0, size_t(0)));
608 // use an eight neighborhood
609 // first row is special
610 // first pixel is special
611 // wrapping does not make sense in the first row: no pixels have been
612 // assigned components yet
613 int curLabel = 0;
614 if (bitmap[0])
615 {
616 (*componentsImg)[0] = ++curLabel;
617 tempLabels.push_back(std::make_pair(curLabel, size_t(1)));
618 }
619 else
620 {
621 (*componentsImg)[0] = 0;
622 ++tempLabels[0].second;
623 }
624 // handle first row
625 for (size_t i = 1; i < uextent; ++i)
626 {
627 // in the first row only the previous pixel has to be considered
628 if (bitmap[i])
629 {
630 if ((*componentsImg)[i - 1])
631 {
632 (*componentsImg)[i] = (*componentsImg)[i - 1];
633 ++tempLabels[(*componentsImg)[i]].second;
634 }
635 else
636 {
637 (*componentsImg)[i] = ++curLabel;
638 tempLabels.push_back(std::make_pair(curLabel, size_t(1)));
639 }
640 }
641 else
642 {
643 (*componentsImg)[i] = 0;
644 ++tempLabels[0].second;
645 }
646 }
647 size_t prevRow, row = 0;
648 size_t jend = vwrap ? vextent - 1 : vextent;
649 for (size_t j = 1; j < jend; ++j)
650 {
651 prevRow = row;
652 row = prevRow + uextent;
653 // first pixel in row gets different treatment
654 if (bitmap[row])
655 {
656 if ((*componentsImg)[prevRow]) // pixel above in component?
657 {
658 (*componentsImg)[row] = (*componentsImg)[prevRow];
659 ++tempLabels[(*componentsImg)[row]].second;
660 }
661 else
662 {
663 int n[2];
664 n[0] = (*componentsImg)[prevRow + 1];
665 if (uwrap)
666 {
667 n[1] = (*componentsImg)[prevRow + uextent - 1];
668 }
669 (*componentsImg)[row] = Label(n, uwrap ? 2 : 1, &curLabel, &tempLabels);
670 }
671 }
672 else
673 {
674 (*componentsImg)[row] = 0;
675 ++tempLabels[0].second;
676 }
677 for (size_t i = 1; i < uextent - 1; ++i)
678 {
679 if (!bitmap[row + i])
680 {
681 (*componentsImg)[row + i] = 0;
682 ++tempLabels[0].second;
683 continue;
684 }
685 int n[4];
686 n[0] = (*componentsImg)[row + i - 1];
687 n[1] = (*componentsImg)[prevRow + i - 1];
688 n[2] = (*componentsImg)[prevRow + i];
689 n[3] = (*componentsImg)[prevRow + i + 1];
690 (*componentsImg)[row + i] = Label(n, 4, &curLabel, &tempLabels);
691 }
692 // last pixel in the row
693 if (!bitmap[row + uextent - 1])
694 {
695 (*componentsImg)[row + uextent - 1] = 0;
696 ++tempLabels[0].second;
697 continue;
698 }
699 int n[5];
700 n[0] = (*componentsImg)[row + uextent - 2];
701 n[1] = (*componentsImg)[prevRow + uextent - 2];
702 n[2] = (*componentsImg)[prevRow + uextent - 1];
703 if (uwrap)
704 {
705 n[3] = (*componentsImg)[prevRow];
706 n[4] = (*componentsImg)[row];
707 }
708 (*componentsImg)[row + uextent - 1] = Label(n, uwrap ? 5 : 3, &curLabel, &tempLabels);
709 }
710 // last row
711 if (vwrap) // in case of vwrapping the last row is computed with almost full
712 // neighborhood
713 {
714 prevRow = (vextent - 2) * uextent;
715 row = (vextent - 1) * uextent;
716 // first pixel
717 if (bitmap[row])
718 {
719 int n[6];
720 n[0] = (*componentsImg)[prevRow];
721 n[1] = (*componentsImg)[prevRow + 1];
722 n[2] = (*componentsImg)[0];
723 n[3] = (*componentsImg)[1];
724 if (uwrap)
725 {
726 n[4] = (*componentsImg)[prevRow + uextent - 1];
727 n[5] = (*componentsImg)[uextent - 1];
728 }
729 (*componentsImg)[row] = Label(n, uwrap ? 6 : 4, &curLabel, &tempLabels);
730 }
731 else
732 {
733 (*componentsImg)[row] = 0;
734 ++tempLabels[0].second;
735 }
736 for (size_t i = 1; i < uextent - 1; ++i)
737 {
738 if (!bitmap[row + i])
739 {
740 (*componentsImg)[row + i] = 0;
741 ++tempLabels[0].second;
742 continue;
743 }
744 int n[7];
745 n[0] = (*componentsImg)[row + i - 1];
746 n[1] = (*componentsImg)[prevRow + i - 1];
747 n[2] = (*componentsImg)[prevRow + i];
748 n[3] = (*componentsImg)[prevRow + i + 1];
749 n[4] = (*componentsImg)[i - 1];
750 n[5] = (*componentsImg)[i];
751 n[6] = (*componentsImg)[i + 1];
752 (*componentsImg)[row + i] = Label(n, 7, &curLabel, &tempLabels);
753 }
754 // last pixel
755 if (!bitmap[row + uextent - 1])
756 {
757 (*componentsImg)[row + uextent - 1] = 0;
758 ++tempLabels[0].second;
759 }
760 else
761 {
762 int n[8];
763 n[0] = (*componentsImg)[row + uextent - 2];
764 n[1] = (*componentsImg)[prevRow + uextent - 2];
765 n[2] = (*componentsImg)[prevRow + uextent - 1];
766 n[3] = (*componentsImg)[uextent - 2];
767 n[4] = (*componentsImg)[uextent - 1];
768 if (uwrap)
769 {
770 n[5] = (*componentsImg)[prevRow];
771 n[6] = (*componentsImg)[row];
772 n[7] = (*componentsImg)[0];
773 }
774 (*componentsImg)[row + uextent - 1] = Label(n, uwrap ? 8 : 5, &curLabel, &tempLabels);
775 }
776 }
777 // reduce the tempLabels
778 for (size_t i = tempLabels.size() - 1; i > 0; --i)
779 {
780 tempLabels[i].first = ReduceLabel(i, tempLabels);
781 }
782 MiscLib::Vector<int> condensed(tempLabels.size());
783 labels->clear();
784 labels->reserve(condensed.size());
785 int count = 0;
786 for (size_t i = 0; i < tempLabels.size(); ++i)
787 if (i == (size_t)tempLabels[i].first)
788 {
789 labels->push_back(std::make_pair(count, tempLabels[i].second));
790 condensed[i] = count;
791 ++count;
792 }
793 else
794 (*labels)[condensed[tempLabels[i].first]].second += tempLabels[i].second;
795 // set new component ids
796 for (size_t i = 0; i < componentsImg->size(); ++i)
797 (*componentsImg)[i] = condensed[tempLabels[(*componentsImg)[i]].first];
798}
799
800int
801Label(int n[], int size, int* curLabel, MiscLib::Vector<std::pair<int, size_t>>* labels)
802{
803 // check if components are set
804 int count = 0, found;
805 for (int i = 0; i < size; ++i)
806 {
807 if (n[i])
808 {
809 ++count;
810 found = n[i];
811 }
812 }
813 if (!count)
814 {
815 ++(*curLabel);
816 labels->push_back(std::make_pair(*curLabel, size_t(1)));
817 return *curLabel;
818 }
819 else if (count == 1)
820 {
821 ++(*labels)[found].second;
822 return found;
823 }
824 else
825 {
826 ++(*labels)[found].second;
827 // associate the remaining labels
828 for (int i = 0; i < size; ++i)
829 {
830 if (n[i] && n[i] != found)
831 {
832 AssociateLabel(n[i], found, labels);
833 }
834 }
835 return found;
836 }
837}
838
839void
840AssociateLabel(int a, int b, MiscLib::Vector<std::pair<int, size_t>>* labels)
841{
842 if (a > b)
843 {
844 AssociateLabel(b, a, labels);
845 return;
846 }
847 if ((a == b) || ((*labels)[b].first == a))
848 {
849 return;
850 }
851 if ((*labels)[b].first == b)
852 {
853 (*labels)[b].first = a;
854 }
855 else
856 {
857 AssociateLabel((*labels)[b].first, a, labels);
858 if ((*labels)[b].first > a)
859 {
860 (*labels)[b].first = a;
861 }
862 }
863}
864
865int
866ReduceLabel(int a, const MiscLib::Vector<std::pair<int, size_t>>& labels)
867{
868 if (labels[a].first == a)
869 {
870 return labels[a].first;
871 }
872 return ReduceLabel(labels[a].first, labels);
873}
874
875bool
876IsEdge(const MiscLib::Vector<int>& componentImg,
877 size_t uextent,
878 size_t vextent,
879 int label,
880 bool uwrap,
881 bool vwrap,
882 int startx,
883 int starty,
884 int dirx,
885 int diry,
886 size_t* targetx,
887 size_t* targety)
888{
889 if (dirx > 0)
890 {
891 if ((size_t)startx == uextent)
892 {
893 return false;
894 }
895 if ((size_t)starty == vextent)
896 {
897 return false;
898 }
899 *targetx = (uwrap && (size_t)startx == uextent - 1) ? 0 : startx + 1;
900 *targety = starty;
901 return componentImg[starty * uextent + startx] == label &&
902 ((starty > 0 && componentImg[(starty - 1) * uextent + startx] != label) ||
903 (!vwrap && starty == 0) ||
904 (vwrap && starty == 0 && componentImg[(vextent - 1) * uextent + startx] != label));
905 }
906 if (dirx < 0)
907 {
908 if (!uwrap && startx == 0)
909 {
910 return false;
911 }
912 *targetx = (startx == 0) ? uextent - 1 : startx - 1;
913 *targety = starty;
914 return (!vwrap && (size_t)starty == vextent &&
915 componentImg[(starty - 1) * uextent + (*targetx)] == label) ||
916 ((size_t)starty != vextent &&
917 (componentImg[starty * uextent + (*targetx)] != label &&
918 ((starty > 0 && componentImg[(starty - 1) * uextent + (*targetx)] == label) ||
919 (vwrap && starty == 0 &&
920 componentImg[(vextent - 1) * uextent + (*targetx)] == label))));
921 }
922 if (diry > 0)
923 {
924 if ((size_t)starty == vextent)
925 {
926 return false;
927 }
928 *targetx = startx;
929 *targety = (vwrap && (size_t)starty == vextent - 1) ? 0 : starty + 1;
930 return (!uwrap && (size_t)startx == uextent &&
931 componentImg[starty * uextent + (startx - 1)] == label) ||
932 ((size_t)startx != uextent &&
933 (componentImg[starty * uextent + startx] != label &&
934 (((size_t)startx > 0 && componentImg[starty * uextent + (startx - 1)] == label) ||
935 (uwrap && startx == 0 &&
936 componentImg[starty * uextent + (uextent - 1)] == label))));
937 }
938 if (diry < 0)
939 {
940 if (!vwrap && starty == 0)
941 {
942 return false;
943 }
944 if ((size_t)startx == uextent)
945 {
946 return false;
947 }
948 *targetx = startx;
949 *targety = (starty == 0) ? vextent - 1 : starty - 1;
950 return componentImg[(*targety) * uextent + startx] == label &&
951 ((startx > 0 && componentImg[(*targety) * uextent + (startx - 1)] != label) ||
952 (!uwrap && startx == 0) ||
953 (uwrap && startx == 0 &&
954 componentImg[(*targety) * uextent + (uextent - 1)] != label));
955 }
956 return false;
957}
958
959// finds the loops around a connected component as polygons
960void
961ComponentLoops(const MiscLib::Vector<int>& componentImg,
962 size_t uextent,
963 size_t vextent,
964 int label,
965 bool uwrap,
966 bool vwrap,
967 MiscLib::Vector<MiscLib::Vector<GfxTL::VectorXD<2, size_t>>>* polys)
968{
969 typedef GfxTL::VectorXD<2, size_t> Vec2;
970 // find first point of component
971 size_t firsti = 0;
972 int x, y, prevx, prevy;
973 // the corners of our pixels will be the vertices of our polygons
974 // (x, y) is the upper left corner of the pixel y * uextent + x
975 HashGrid<bool, 4> edges;
976 unsigned int edgesExtent[] = {uextent + 1, vextent + 1, 3, 3};
977 edges.Extent(edgesExtent);
978 bool prevPixelWasWhite = true;
979 do
980 {
981 // find the first edge in the polygon
982 // edges are oriented so that the "black" pixels are on the right
983 // black pixels are pixels == label
984 for (; firsti < componentImg.size(); ++firsti)
985 {
986 if (prevPixelWasWhite && componentImg[firsti] == label)
987 {
988 prevPixelWasWhite = false;
989 x = firsti % uextent;
990 y = firsti / uextent;
991 break;
992 }
993 prevPixelWasWhite = componentImg[firsti] != label;
994 }
995 if (firsti >= componentImg.size()) // unable to find a pixel -> good bye
996 {
997 // if there is a uwrap, then the last row could be an outer loop
998 // this outer loop could be missed of all pixels in the last
999 // row are black
1000 // to find that out we spawn another trial at the first
1001 // pixel in the last row (if it is black)
1002 // if the loop has already been detected, than this
1003 // edge should already be in edges
1004 if (!uwrap)
1005 {
1006 break;
1007 }
1008 if (componentImg[(vextent - 1) * uextent] == label)
1009 {
1010 x = 0;
1011 y = vextent - 1;
1012 }
1013 }
1014 MiscLib::Vector<Vec2> poly;
1015 // we initialize the path with an oriented edge
1016 // since the black pixel is on the right the edge goes from
1017 // bottom to top, i.e. from (x, y + 1) to (x, y)
1018 if ((x > 0 && (size_t)y < vextent - 1) || (!uwrap && !vwrap) || (vwrap && !uwrap && y == 0))
1019 {
1020 // on the left of pixel
1021 // check if edge was visited already
1022 unsigned int edgeIndex[] = {x, y, 1, 2};
1023 if (edges.find(edgeIndex))
1024 {
1025 continue;
1026 }
1027 prevx = 0;
1028 prevy = 1;
1029 }
1030 else if (uwrap && !vwrap && x == 0 && (size_t)y != vextent - 1)
1031 {
1032 size_t dx, dy;
1033 if (!IsEdge(componentImg, uextent, vextent, label, uwrap, vwrap, x, y, 1, 0, &dx, &dy))
1034 {
1035 continue;
1036 }
1037 // check if edge was visited already
1038 unsigned int edgeIndex[] = {x + 1, y, 0, 1};
1039 if (edges.find(edgeIndex))
1040 {
1041 continue;
1042 }
1043 // on top of pixel
1044 prevx = -1;
1045 prevy = 0;
1046 ++x;
1047 }
1048 else if (uwrap && !vwrap && x == 0 && (size_t)y == vextent - 1)
1049 {
1050 size_t dx, dy;
1051 if (!IsEdge(componentImg,
1052 uextent,
1053 vextent,
1054 label,
1055 uwrap,
1056 vwrap,
1057 x + 1,
1058 y + 1,
1059 -1,
1060 0,
1061 &dx,
1062 &dy))
1063 {
1064 continue;
1065 }
1066 // on bottom of pixel
1067 // check if edge was visited already
1068 unsigned int edgeIndex[] = {x + 1, y + 1, 0, 1};
1069 if (edges.find(edgeIndex))
1070 {
1071 continue;
1072 }
1073 prevx = -1;
1074 prevy = 0;
1075 ++y;
1076 }
1077 else if (!uwrap && vwrap && (size_t)x == uextent - 1)
1078 {
1079 // on right of pixel
1080 size_t dx, dy;
1081 if (!IsEdge(componentImg,
1082 uextent,
1083 vextent,
1084 label,
1085 uwrap,
1086 vwrap,
1087 x + 1,
1088 y + 1,
1089 0,
1090 -1,
1091 &dx,
1092 &dy))
1093 {
1094 continue;
1095 }
1096 // on bottom of pixel
1097 // check if edge was visited already
1098 unsigned int edgeIndex[] = {x + 1, y + 1, 1, 0};
1099 if (edges.find(edgeIndex))
1100 {
1101 continue;
1102 }
1103 prevx = 0;
1104 prevy = 1;
1105 ++y;
1106 }
1107 else
1108 {
1109 continue; // we are unable to start a loop at this position
1110 }
1111 poly.push_back(Vec2(x + prevx, y + prevy));
1112 edges[x][y][prevx + 1][prevy + 1] = true;
1113 do
1114 {
1115 poly.push_back(Vec2(x, y));
1116 // check the four neighbors of (x, y) from left to right
1117 // starting from where we came from
1118 // we take the first edge that we encounter
1119 size_t nextx, nexty;
1120 size_t checkEdge;
1121 for (checkEdge = 0; checkEdge < 3; ++checkEdge)
1122 {
1123 std::swap(prevx, prevy);
1124 prevx *= -1;
1125 if (IsEdge(componentImg,
1126 uextent,
1127 vextent,
1128 label,
1129 uwrap,
1130 vwrap,
1131 x,
1132 y,
1133 prevx,
1134 prevy,
1135 &nextx,
1136 &nexty))
1137 {
1138 break;
1139 }
1140 }
1141 if (checkEdge > 3)
1142 {
1143 return;
1144 }
1145 x = nextx;
1146 y = nexty;
1147 prevx = -prevx;
1148 prevy = -prevy;
1149 edges[x][y][prevx + 1][prevy + 1] = true;
1150 } while (poly[0] != Vec2(x, y));
1151 polys->push_back(poly);
1152 } while (firsti < componentImg.size());
1153#ifdef _DEBUG
1154 static int fname_int = 0;
1155 std::ostringstream fn;
1156 fn << "ComponentLoopsInput" << fname_int << ".txt";
1157 std::ofstream file;
1158 file.open(fn.str().c_str(), std::ios::out);
1159 for (size_t j = 0; j < vextent; ++j)
1160 {
1161 for (size_t i = 0; i < uextent; ++i)
1162 {
1163 file /*<< std::setw(3)*/ << componentImg[j * uextent + i] /* << " "*/;
1164 }
1165 file << std::endl;
1166 }
1167 file.close();
1168 MiscLib::Vector<int> loopsImg((uextent + 1) * (vextent + 1), 0);
1169 std::ostringstream fn2;
1170 fn2 << "ComponentLoopsOutput" << fname_int++ << ".txt";
1171 for (size_t i = 0; i < polys->size(); ++i)
1172 for (size_t j = 0; j < (*polys)[i].size(); ++j)
1173 {
1174 loopsImg[(*polys)[i][j][1] * (uextent + 1) + (*polys)[i][j][0]] = i + 1;
1175 }
1176 file.open(fn2.str().c_str(), std::ios::out);
1177 for (size_t j = 0; j < vextent + 1; ++j)
1178 {
1179 for (size_t i = 0; i < uextent + 1; ++i)
1180 {
1181 file /*<< std::setw(3)*/ << loopsImg[j * (uextent + 1) + i] /* << " "*/;
1182 }
1183 file << std::endl;
1184 }
1185 file.close();
1186#endif
1187}
ReduceLabel
int ReduceLabel(int a, const MiscLib::Vector< std::pair< int, size_t > > &labels)
Definition Bitmap.cpp:866
IsEdge
bool IsEdge(const MiscLib::Vector< int > &componentImg, size_t uextent, size_t vextent, int label, bool uwrap, bool vwrap, int startx, int starty, int dirx, int diry, size_t *targetx, size_t *targety)
Definition Bitmap.cpp:876
DilateCross
void DilateCross(const MiscLib::Vector< char > &bitmap, size_t uextent, size_t vextent, bool uwrap, bool vwrap, MiscLib::Vector< char > *dilated)
Definition Bitmap.cpp:144
ErodeCross
void ErodeCross(const MiscLib::Vector< char > &bitmap, size_t uextent, size_t vextent, bool uwrap, bool vwrap, MiscLib::Vector< char > *eroded)
Definition Bitmap.cpp:425
ErodeSquare
void ErodeSquare(const MiscLib::Vector< char > &bitmap, size_t uextent, size_t vextent, bool uwrap, bool vwrap, MiscLib::Vector< char > *eroded)
Definition Bitmap.cpp:247
DilateSquare
void DilateSquare(const MiscLib::Vector< char > &bitmap, size_t uextent, size_t vextent, bool uwrap, bool vwrap, MiscLib::Vector< char > *dilated)
Definition Bitmap.cpp:16
PreWrappedComponents
void PreWrappedComponents(const MiscLib::Vector< char > &bitmap, size_t uextent, size_t vextent, MiscLib::Vector< int > *preWrappedComponentsImg, MiscLib::Vector< int > *relabelComponentsImg, const MiscLib::Vector< std::pair< int, size_t > > &inLabels, MiscLib::Vector< std::pair< int, size_t > > *labels)
Definition Bitmap.cpp:527
AssociateLabel
void AssociateLabel(int a, int b, MiscLib::Vector< std::pair< int, size_t > > *labels)
Definition Bitmap.cpp:840
ComponentLoops
void ComponentLoops(const MiscLib::Vector< int > &componentImg, size_t uextent, size_t vextent, int label, bool uwrap, bool vwrap, MiscLib::Vector< MiscLib::Vector< GfxTL::VectorXD< 2, size_t > > > *polys)
Definition Bitmap.cpp:961
totalTime_components
MiscLib::performance_t totalTime_components
Label
int Label(int n[], int size, int *curLabel, MiscLib::Vector< std::pair< int, size_t > > *labels)
Definition Bitmap.cpp:801
Components
void Components(const MiscLib::Vector< char > &bitmap, size_t uextent, size_t vextent, bool uwrap, bool vwrap, MiscLib::Vector< int > *componentsImg, MiscLib::Vector< std::pair< int, size_t > > *labels)
Definition Bitmap.cpp:596
Grid.h
HashGrid::Extent
void Extent(const ExtentT &extent)
Definition Grid.h:331
HashGrid::find
CellT * find(const IndexT &index)
Definition Grid.h:373
MiscLib::Vector::resize
void resize(size_type s, const value_type &v)
Definition Vector.h:227
MiscLib::Vector::size
size_type size() const
Definition Vector.h:215
MiscLib::Vector::push_back
void push_back(const T &v)
Definition Vector.h:354
MiscLib::Vector::reserve
void reserve(size_type s)
Definition Vector.h:189
MiscLib::performance_t
clock_t performance_t
Definition Performance.h:31
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition ArmarXTimeserver.cpp:28