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>
12 using namespace MiscLib;
13 extern MiscLib::performance_t totalTime_components;
14 
15 void
16 DilateSquare(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 
143 void
144 DilateCross(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 
246 void
247 ErodeSquare(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 
424 void
425 ErodeCross(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 
526 void
527 PreWrappedComponents(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 
595 void
596 Components(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 
800 int
801 Label(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 
839 void
840 AssociateLabel(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 
865 int
866 ReduceLabel(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 
875 bool
876 IsEdge(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
960 void
961 ComponentLoops(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 }
GfxTL::VectorXD
Definition: MatrixXX.h:24
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
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
Label
int Label(int n[], int size, int *curLabel, MiscLib::Vector< std::pair< int, size_t >> *labels)
Definition: Bitmap.cpp:801
MiscLib::Vector::push_back
void push_back(const T &v)
Definition: Vector.h:354
Performance.h
MiscLib::Vector::resize
void resize(size_type s, const value_type &v)
Definition: Vector.h:227
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
Bitmap.h
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
AssociateLabel
void AssociateLabel(int a, int b, MiscLib::Vector< std::pair< int, size_t >> *labels)
Definition: Bitmap.cpp:840
HashGrid
Definition: Grid.h:309
magic_enum::detail::n
constexpr auto n() noexcept
Definition: magic_enum.hpp:418
MiscLib::Vector< char >
VectorXD.h
Grid.h
armarx::armem::client::util::swap
void swap(SubscriptionHandle &first, SubscriptionHandle &second)
Definition: SubscriptionHandle.cpp:66
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
MiscLib::Vector::size
size_type size() const
Definition: Vector.h:215
armarx::ctrlutil::a
double a(double t, double a0, double j)
Definition: CtrlUtil.h:45
MiscLib::performance_t
clock_t performance_t
Definition: Performance.h:31
MiscLib
Definition: AlignedAllocator.h:12
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
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
MiscLib::Vector::reserve
void reserve(size_type s)
Definition: Vector.h:189
ReduceLabel
int ReduceLabel(int a, const MiscLib::Vector< std::pair< int, size_t >> &labels)
Definition: Bitmap.cpp:866
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
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:27
totalTime_components
MiscLib::performance_t totalTime_components
HashGrid::find
CellT * find(const IndexT &index)
Definition: Grid.h:373
HashGrid::Extent
void Extent(const ExtentT &extent)
Definition: Grid.h:331