// 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_