otbAttributesMapLabelObject.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef otbAttributesMapLabelObject_h
#define otbAttributesMapLabelObject_h
 
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include "itkShapeLabelObject.h"
#pragma GCC diagnostic pop
#else
#include "itkShapeLabelObject.h"
#endif
 
#include "otbPolygon.h"
#include <map>
#include <string>
 
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 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 == nullptr)
    {
      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())
  {
  }
 
  ~AttributesMapLabelObject() override
  {
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override
  {
    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&) = delete;
  void operator=(const Self&) = delete;
 
  AttributesMapType m_Attributes;
 
  PolygonPointerType m_Polygon;
};
 
} // end namespace otb
#endif