DFastAreaOpening.h

#ifndef _DFAST_AREA_OPENING_H_
#define _DFAST_AREA_OPENING_H_
 
#include "Core/include/DCore.h"
 
namespace smil
{
  // AREA OPENING
 
  template <class T1, class T2>
  RES_T ImAreaClosing_PixelQueue(const Image<T1> &imIn, int size,
                                 Image<T2> &imOut);
 
  template <class T1, class T2>
  RES_T ImAreaOpening_PixelQueue(const Image<T1> &imIn, int size,
                                 Image<T2> &imOut)
  {
    ASSERT_ALLOCATED(&imIn)
    ASSERT_SAME_SIZE(&imIn, &imOut)
    Image<T1> imNeg(imIn);
    RES_T res = inv(imIn, imNeg);
    if (res != RES_OK)
      return res;
    res = ImAreaClosing_PixelQueue(imNeg, size, imOut);
    if (res != RES_OK)
      return res;
    return inv(imOut, imOut);
  }
 
  template <class T1, class T2>
  RES_T ImAreaOpening_MaxTree(const Image<T1> &imIn, int size,
                              Image<T2> &imOut);
 
  template <class T1, class T2>
  RES_T ImAreaClosing_MaxTree(const Image<T1> &imIn, int size, Image<T2> &imOut)
  {
    ASSERT_ALLOCATED(&imIn)
    ASSERT_SAME_SIZE(&imIn, &imOut)
    Image<T1> imNeg(imIn);
    RES_T res = inv(imIn, imNeg);
    if (res != RES_OK)
      return res;
    res = ImAreaOpening_MaxTree(imNeg, size, imOut);
    if (res != RES_OK)
      return res;
    return inv(imOut, imOut);
  }
 
  template <class T1, class T2>
  RES_T ImAreaOpening_UnionFind(const Image<T1> &imIn, int size,
                                Image<T2> &imOut);
 
  template <class T1, class T2>
  RES_T ImAreaClosing_UnionFind(const Image<T1> &imIn, int size,
                                Image<T2> &imOut)
  {
    ASSERT_ALLOCATED(&imIn)
    ASSERT_SAME_SIZE(&imIn, &imOut)
    Image<T1> imNeg(imIn);
    RES_T res = inv(imIn, imNeg);
    if (res != RES_OK)
      return res;
    res = ImAreaOpening_UnionFind(imNeg, size, imOut);
    if (res != RES_OK)
      return res;
    return inv(imOut, imOut);
  }
 
  template <class T1, class T2>
  RES_T ImAreaOpening_Line(const Image<T1> &imIn, int size, Image<T2> &imOut);
 
  template <class T1, class T2>
  RES_T ImAreaClosing_Line(const Image<T1> &imIn, int size, Image<T2> &imOut)
  {
    ASSERT_ALLOCATED(&imIn)
    ASSERT_SAME_SIZE(&imIn, &imOut)
    Image<T1> imNeg(imIn);
    RES_T res = inv(imIn, imNeg);
    if (res != RES_OK)
      return res;
    res = ImAreaOpening_Line(imNeg, size, imOut);
    if (res != RES_OK)
      return res;
    return inv(imOut, imOut);
  }
 
  template <class T1, class T2>
  RES_T ImAreaOpening_LineSupEqu(const Image<T1> &imIn, int size,
                                 Image<T2> &imOut);
 
  // INERTIA THINNINGS
 
  template <class T1, class T2>
  RES_T ImInertiaThinning_MaxTree(const Image<T1> &imIn, double size,
                                  Image<T2> &imOut);
 
  template <class T1, class T2>
  RES_T ImInertiaThickening_MaxTree(const Image<T1> &imIn, double size,
                                    Image<T2> &imOut)
  {
    ASSERT_ALLOCATED(&imIn)
    ASSERT_SAME_SIZE(&imIn, &imOut)
    Image<T1> imNeg(imIn);
    RES_T res = inv(imIn, imNeg);
    if (res != RES_OK)
      return res;
    res = ImInertiaThinning_MaxTree(imNeg, size, imOut);
    if (res != RES_OK)
      return res;
    return inv(imOut, imOut);
  }
 
} // namespace smil
 
// FastAreaOpening Module header
#include "FastAreaOpening/AreaOpeningPixelQueue.hpp"
#include "FastAreaOpening/AreaOpeningMaxTree.hpp"
#include "FastAreaOpening/AreaOpeningUnionFind.hpp"
#include "FastAreaOpening/AreaOpeningLine.hpp"
 
#endif // _DFAST_AREA_OPENING_H_