itkKLMSegmentationBorder.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkKLMSegmentationBorder.h,v $
  Language:  C++
  Date:      $Date: 2002/01/15 18:57:02 $
  Version:   $Revision: 1.3 $

  Copyright (c) 2002 Insight 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 _itkKLMSegmentationBorder_h
#define _itkKLMSegmentationBorder_h

#include "itkObject.h"
#include "itkSegmentationBorder.h"

#include "itkKLMSegmentationRegion.h"
#include "itkExceptionObject.h"

#include "vnl/vnl_matrix.h"
namespace itk
{

template <class TBorder> 
class KLMDynamicBorderArray
{
public:
  bool operator> (const KLMDynamicBorderArray<TBorder>& rhs) const
    {  
    if( m_Pointer->GetLambda() == rhs.m_Pointer->GetLambda() ) 
      { 

      unsigned int lhsArea = ( m_Pointer->GetRegion1()->GetRegionArea() + 
        m_Pointer->GetRegion2()->GetRegionArea() );

      unsigned int rhsArea = ( rhs.m_Pointer->GetRegion1()->GetRegionArea() + 
        rhs.m_Pointer->GetRegion2()->GetRegionArea() );

      // Compare the total areas of the two neighbors
      if( lhsArea == rhsArea )
        {
        return ( m_Pointer > rhs.m_Pointer );
        }
      else
        {
        return ( lhsArea > rhsArea );
        }
      }
    return(m_Pointer->GetLambda() > rhs.m_Pointer->GetLambda() ); 
    }

  bool operator> (const KLMDynamicBorderArray<TBorder>* rhs) const
    { 
    if( m_Pointer->GetLambda() == rhs.m_Pointer->GetLambda() ) 
      { 
      return ( m_Pointer > rhs.m_Pointer );
      }
    return(m_Pointer->GetLambda() > rhs.m_Pointer->GetLambda() ); 
    }

  TBorder *m_Pointer;
};

class KLMSegmentationRegion;

class ITK_EXPORT KLMSegmentationBorder : public SegmentationBorder
{
private:
  typedef vnl_matrix<double> VecDblType;

public:
  typedef KLMSegmentationBorder   Self;
  typedef SegmentationBorder Superclass;
  typedef SmartPointer<Self>  Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(KLMSegmentationBorder,SegmentationBorder);

  void SetRegion1(KLMSegmentationRegion *Region1);

  KLMSegmentationRegion *GetRegion1();

  void SetRegion2(KLMSegmentationRegion *Region2);

  KLMSegmentationRegion *GetRegion2();

  itkSetMacro(Lambda, double);

  itkGetMacro(Lambda, double);

  void EvaluateLambda();

  void PrintBorderInfo();

  bool operator> (const KLMSegmentationBorder& rhs) const
    { return( m_Lambda > rhs.m_Lambda ); }
//    { if( m_Lambda == rhs.m_Lambda) { return ( this > &rhs ); }
      

  bool operator> (const KLMSegmentationBorder* rhs) const
    { return( (m_Lambda > rhs->m_Lambda) ); }
//    { if( m_Lambda == rhs->m_Lambda) { return ( this > rhs ); }
      

protected:
  KLMSegmentationBorder();

  ~KLMSegmentationBorder();

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

private:
  KLMSegmentationBorder(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  double                                m_Lambda;
  KLMSegmentationRegion *m_Region1;
  KLMSegmentationRegion *m_Region2;


}; // class KLMSegmentationBorder


} // namespace itk


#endif

---