itkFlatStructuringElement.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkFlatStructuringElement.h,v $
  Language:  C++
  Date:      $Date: 2008-12-06 13:28:10 $
  Version:   $Revision: 1.16 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef __itkFlatStructuringElement_h
#define __itkFlatStructuringElement_h

#include "itkNeighborhood.h"
#include "itkSize.h"
#include "itkOffset.h"
#include <vector>
#include "itkVector.h"

namespace itk {

template<unsigned int VDimension>
class ITK_EXPORT FlatStructuringElement : public Neighborhood <bool, VDimension>
{
public:
  typedef FlatStructuringElement< VDimension>    Self;
  typedef Neighborhood<bool, VDimension>         Superclass;

  typedef typename Superclass::PixelType         PixelType;

  typedef typename Superclass::Iterator          Iterator;
  typedef typename Superclass::ConstIterator     ConstIterator;

  typedef typename Superclass::SizeType          SizeType;
  typedef typename Superclass::SizeValueType     SizeValueType;
  typedef typename Superclass::OffsetType        OffsetType;

  typedef typename Superclass::RadiusType        RadiusType;

  typedef typename Superclass::SliceIteratorType SliceIteratorType;

  itkStaticConstMacro(NeighborhoodDimension, unsigned int, VDimension);

  typedef Vector<float, VDimension>              LType;
  typedef std::vector<LType>                     DecompType;

  virtual ~FlatStructuringElement() {}

  FlatStructuringElement() {m_Decomposable=false;}

  static Self Box(RadiusType radius);

  static Self Ball(RadiusType radius);

  static Self Cross( RadiusType radius );

  static Self Annulus( RadiusType radius,
                       unsigned int thickness = 1,
                       bool includeCenter = false );

  static Self Poly(RadiusType radius, unsigned lines);

  bool GetDecomposable() const
    {
    return m_Decomposable;
    }

  const DecompType & GetLines() const
    {
    return(m_Lines);
    }

  void PrintSelf(std::ostream &os, Indent indent) const;

   
protected:

  void ComputeBufferFromLines();


private:
  bool m_Decomposable;

  DecompType m_Lines;
  
  // dispatch between 2D and 3D
  struct DispatchBase {};
  template<unsigned int VDimension2>
  struct Dispatch : DispatchBase {};

  virtual FlatStructuringElement PolySub(const Dispatch<2> &, 
                                         RadiusType radius, 
                                         unsigned lines) const;

  virtual FlatStructuringElement PolySub(const Dispatch<3> &, 
                                         RadiusType radius, 
                                         unsigned lines) const;

  virtual FlatStructuringElement PolySub(const DispatchBase &, 
                                         RadiusType radius, 
                                         unsigned lines) const;


  bool checkParallel(LType NewVec, DecompType Lines);

  template<unsigned int VDimension3>
  struct StructuringElementFacet
    {
    LType P1, P2, P3;
    };
  typedef StructuringElementFacet<VDimension> FacetType;
};
} // namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkFlatStructuringElement.txx"
#endif


#endif