otbAttributesMapLabelObject.h

Go to the documentation of this file.

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

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt 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 __otbAttributesMapLabelObject_h
#define __otbAttributesMapLabelObject_h

#include "itkLabelObject.h"
#include "itkLabelMap.h"
#include "otbPolygon.h"
#include <map>

namespace otb
{

namespace Functor
{

template<class TLabelObject>
class ITK_EXPORT AttributesMapLabelObjectAccessor
{
public:
  // The Label Object typedef
  typedef TLabelObject                                  LabelObjectType;
  typedef typename LabelObjectType::AttributesValueType AttributeValueType;

  inline const AttributeValueType operator ()(LabelObjectType * labelObject) const
  {
    return labelObject->GetAttribute(m_AttributeName.c_str());
  }

  void SetAttributeName(const char * name)
  {
    m_AttributeName = name;
  }
  const char * GetAttributeName() const
  {
    return m_AttributeName.c_str();
  }

  AttributesMapLabelObjectAccessor() : m_AttributeName("") {}

  ~AttributesMapLabelObjectAccessor() {}

private:
  std::string m_AttributeName;
};


template<class TLabelObject, class TMeasurementVector>
class AttributesMapMeasurementFunctor
{
public:
  typedef std::vector<std::string> AttributesListType;

  inline TMeasurementVector operator()(const TLabelObject * object) const
  {
    TMeasurementVector newSample(m_Attributes.size());

    unsigned int attrIndex = 0;
    typename AttributesListType::const_iterator attrIt = m_Attributes.begin();
    while(attrIt != m_Attributes.end())
      {
      newSample[attrIndex] = object->GetAttribute(attrIt->c_str());
      ++attrIt;
      ++attrIndex;
      }
    return newSample;
  }

  void AddAttribute(const char * attr)
  {
    m_Attributes.push_back(attr);
  }

  void RemoveAttribute(const char * attr)
  {
    AttributesListType::iterator elt = std::find(m_Attributes.begin(), m_Attributes.end(), attr);
    if(elt!=m_Attributes.end())
      {
      m_Attributes.erase(elt);
      }
  }

  void ClearAttributes()
  {
    m_Attributes.clear();
  }

  unsigned int GetNumberOfAttributes()
  {
    return m_Attributes.size();
  }

private:
  AttributesListType m_Attributes;
};

} // end namespace Functor

template <class TLabel, unsigned int VImageDimension, class TAttributesValue>
class ITK_EXPORT AttributesMapLabelObject
  : public itk::LabelObject<TLabel, VImageDimension>
{
public:
  typedef AttributesMapLabelObject                  Self;
  typedef itk::LabelObject<TLabel, VImageDimension> Superclass;
  typedef typename Superclass::LabelObjectType      LabelObjectType;
  typedef itk::SmartPointer<Self>                   Pointer;
  typedef itk::SmartPointer<const Self>             ConstPointer;
  typedef itk::WeakPointer <const Self>             ConstWeakPointer;

  itkNewMacro(Self);

  itkTypeMacro(AttributesMapLabelObject, LabelObject);

  itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension);

  typedef itk::LabelMap<Self> LabelMapType;

  typedef TLabel           LabelType;
  typedef TAttributesValue AttributesValueType;

  // Convenient inherited typedefs
  typedef typename Superclass::IndexType         IndexType;
  typedef typename Superclass::LineType          LineType;
  typedef typename Superclass::LengthType        LengthType;
  typedef typename Superclass::LineContainerType LineContainerType;

  typedef std::map<std::string, AttributesValueType> AttributesMapType;
  typedef typename AttributesMapType::iterator       AttributesMapIteratorType;
  typedef typename AttributesMapType::const_iterator AttributesMapConstIteratorType;

  // The polygon corresponding to the label object
  typedef Polygon<double>               PolygonType;
  typedef typename PolygonType::Pointer PolygonPointerType;

  void SetAttribute(const char * name, AttributesValueType value)
  {
    m_Attributes[name] = value;
  }

  void SetAttribute(const std::string& name, AttributesValueType value)
  {
    this->SetAttribute(name.c_str(), value);
  }

  AttributesValueType GetAttribute(const char * name) const
  {
    AttributesMapConstIteratorType it = m_Attributes.find(name);
    if (it != m_Attributes.end())
      {
      return it->second;
      }
    else
      {
      itkExceptionMacro(<< "Could not find attribute named " << name << ".");
      }
  }

  unsigned int GetNumberOfAttributes() const
  {
    return m_Attributes.size();
  }

  std::vector<std::string> GetAvailableAttributes() const
  {
    std::vector<std::string> attributesNames;

    AttributesMapConstIteratorType it = m_Attributes.begin();

    while (it != m_Attributes.end())
      {
      attributesNames.push_back(it->first);
      ++it;
      }
    return attributesNames;
  }

  virtual void CopyAttributesFrom(const LabelObjectType * lo)
  {
    Superclass::CopyAttributesFrom(lo);

    // copy the data of the current type if possible
    const Self * src = dynamic_cast<const Self *>(lo);
    if (src == NULL)
      {
      return;
      }
    m_Attributes = src->m_Attributes;
  }

  const PolygonType * GetPolygon() const
  {
    return m_Polygon;
  }

  PolygonType * GetPolygon()
  {
    return m_Polygon;
  }

  void SetPolygon(PolygonType* p)
  {
    m_Polygon = p;
  }

protected:
  AttributesMapLabelObject() : m_Attributes(), m_Polygon(PolygonType::New()) {}
  virtual ~AttributesMapLabelObject() {}

  void PrintSelf(std::ostream& os, itk::Indent indent) const
  {
    Superclass::PrintSelf(os, indent);
    os << indent << "Attributes: " << std::endl;
    for (AttributesMapConstIteratorType it = m_Attributes.begin();
         it != m_Attributes.end(); ++it)
      {
      os << indent << indent << it->first << " = " << it->second << std::endl;
      }
  }
private:
  AttributesMapLabelObject(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented

  AttributesMapType m_Attributes;

  PolygonPointerType m_Polygon;
};

} // end namespace otb
#endif