1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
|
// Copyright (C) 2006 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#undef DLIB_MORPHOLOGICAL_OPERATIONs_ABSTRACT_
#ifdef DLIB_MORPHOLOGICAL_OPERATIONs_ABSTRACT_
#include "../pixel.h"
#include "thresholding_abstract.h"
#include "../image_processing/generic_image.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
template <
typename in_image_type,
typename out_image_type,
long M,
long N
>
void binary_dilation (
const in_image_type& in_img,
out_image_type& out_img,
const unsigned char (&structuring_element)[M][N]
);
/*!
requires
- in_image_type and out_image_type are image objects that implement the
interface defined in dlib/image_processing/generic_image.h
- in_img must contain a grayscale pixel type.
- both in_img and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- is_same_object(in_img,out_img) == false
- M % 2 == 1 (i.e. M must be odd)
- N % 2 == 1 (i.e. N must be odd)
- all pixels in in_img are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
- all pixels in structuring_element are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
ensures
- Does a binary dilation of in_img using the given structuring element and
stores the result in out_img.
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type,
typename out_image_type,
long M,
long N
>
void binary_erosion (
const in_image_type& in_img,
out_image_type& out_img,
const unsigned char (&structuring_element)[M][N]
);
/*!
requires
- in_image_type and out_image_type are image objects that implement the
interface defined in dlib/image_processing/generic_image.h
- in_img must contain a grayscale pixel type.
- both in_img and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- is_same_object(in_img,out_img) == false
- M % 2 == 1 (i.e. M must be odd)
- N % 2 == 1 (i.e. N must be odd)
- all pixels in in_img are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
- all pixels in structuring_element are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
ensures
- Does a binary erosion of in_img using the given structuring element and
stores the result in out_img.
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type,
typename out_image_type,
long M,
long N
>
void binary_open (
const in_image_type& in_img,
out_image_type& out_img,
const unsigned char (&structuring_element)[M][N],
const unsigned long iter = 1
);
/*!
requires
- in_image_type and out_image_type are image objects that implement the
interface defined in dlib/image_processing/generic_image.h
- in_img must contain a grayscale pixel type.
- both in_img and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- is_same_object(in_img,out_img) == false
- M % 2 == 1 (i.e. M must be odd)
- N % 2 == 1 (i.e. N must be odd)
- all pixels in in_img are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
- all pixels in structuring_element are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
ensures
- Does a binary open of in_img using the given structuring element and
stores the result in out_img. Specifically, iter iterations of binary
erosion are applied and then iter iterations of binary dilation.
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type,
typename out_image_type,
long M,
long N
>
void binary_close (
const in_image_type& in_img,
out_image_type& out_img,
const unsigned char (&structuring_element)[M][N],
const unsigned long iter = 1
);
/*!
requires
- in_image_type and out_image_type are image objects that implement the
interface defined in dlib/image_processing/generic_image.h
- in_img must contain a grayscale pixel type.
- both in_img and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- is_same_object(in_img,out_img) == false
- M % 2 == 1 (i.e. M must be odd)
- N % 2 == 1 (i.e. N must be odd)
- all pixels in in_img are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
- all pixels in structuring_element are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
ensures
- Does a binary close of in_img using the given structuring element and
stores the result in out_img. Specifically, iter iterations of binary
dilation are applied and then iter iterations of binary erosion.
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type1,
typename in_image_type2,
typename out_image_type
>
void binary_intersection (
const in_image_type1& in_img1,
const in_image_type2& in_img2,
out_image_type& out_img
);
/*!
requires
- in_image_type1, in_image_type2, and out_image_type are image objects that
implement the interface defined in dlib/image_processing/generic_image.h
- in_img1 and in_img2 must contain grayscale pixel types.
- in_img1, in_img2, and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- all pixels in in_img1 and in_img2 are set to either on_pixel or off_pixel
(i.e. they must be binary images)
- in_img1.nc() == in_img2.nc()
- in_img1.nr() == in_img2.nr()
ensures
- #out_img == the binary intersection of in_img1 and in_img2. (i.e. All
the pixels that are set to on_pixel in both in_img1 and in_img2 will be set
to on_pixel in #out_img. All other pixels will be set to off_pixel)
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type1,
typename in_image_type2,
typename out_image_type
>
void binary_union (
const in_image_type1& in_img1,
const in_image_type2& in_img2,
out_image_type& out_img
);
/*!
requires
- in_image_type1, in_image_type2, and out_image_type are image objects that
implement the interface defined in dlib/image_processing/generic_image.h
- in_img1 and in_img2 must contain grayscale pixel types.
- in_img1, in_img2, and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- all pixels in in_img1 and in_img2 are set to either on_pixel or off_pixel
(i.e. they must be binary images)
- in_img1.nc() == in_img2.nc()
- in_img1.nr() == in_img2.nr()
ensures
- #out_img == the binary union of in_img1 and in_img2. (i.e. All
the pixels that are set to on_pixel in in_img1 and/or in_img2 will be set
to on_pixel in #out_img. All other pixels will be set to off_pixel)
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type1,
typename in_image_type2,
typename out_image_type
>
void binary_difference (
const in_image_type1& in_img1,
const in_image_type2& in_img2,
out_image_type& out_img
);
/*!
requires
- in_image_type1, in_image_type2, and out_image_type are image objects that
implement the interface defined in dlib/image_processing/generic_image.h
- in_img1 and in_img2 must contain grayscale pixel types.
- in_img1, in_img2, and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- all pixels in in_img1 and in_img2 are set to either on_pixel or off_pixel
(i.e. they must be binary images)
- in_img1.nc() == in_img2.nc()
- in_img1.nr() == in_img2.nr()
ensures
- #out_img == the binary difference of in_img1 and in_img2. (i.e. #out_img
will be a copy of in_img1 except that any pixels in in_img2 that are set to
on_pixel will be set to off_pixel)
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
// ----------------------------------------------------------------------------------------
template <
typename in_image_type,
typename out_image_type
>
void binary_complement (
const in_image_type& in_img,
out_image_type& out_img
);
/*!
requires
- in_image_type and out_image_type are image objects that implement the
interface defined in dlib/image_processing/generic_image.h
- in_img must contain a grayscale pixel type.
- both in_img and out_img must contain pixels with no alpha channel.
(i.e. pixel_traits::has_alpha==false for their pixels)
- all pixels in in_img are set to either on_pixel or off_pixel
(i.e. it must be a binary image)
ensures
- #out_img == the binary complement of in_img. (i.e. For each pixel in
in_img, if it is on_pixel then it will be set to off_pixel in #out_img and
if it was off_pixel in in_img then it will be on_pixel in #out_img)
- #out_img.nc() == in_img.nc()
- #out_img.nr() == in_img.nr()
!*/
template <
typename image_type
>
void binary_complement (
image_type& img
);
/*!
requires
- it must be valid to call binary_complement(img,img);
ensures
- calls binary_complement(img,img);
!*/
// ----------------------------------------------------------------------------------------
template <
typename image_type
>
void skeleton(
image_type& img
);
/*!
requires
- image_type is an object that implement the interface defined in
dlib/image_processing/generic_image.h
- img must contain a grayscale pixel type.
- all pixels in img are set to either on_pixel or off_pixel.
(i.e. it must be a binary image)
ensures
- This function computes the skeletonization of img and stores the result in
#img. That is, given a binary image, we progressively thin the binary blobs
(composed of on_pixel values) until only a single pixel wide skeleton of the
original blobs remains.
- #img.nc() == img.nc()
- #img.nr() == img.nr()
!*/
// ----------------------------------------------------------------------------------------
}
#endif // DLIB_MORPHOLOGICAL_OPERATIONs_ABSTRACT_
|
