otbLabelObjectToPolygonFunctor.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 otbLabelObjectToPolygonFunctor_h
#define otbLabelObjectToPolygonFunctor_h
 
#include <vector>
 
// TODO change this include  have to define from what inherate this class
#include "otbPolyLineParametricPathWithValue.h" //for std::abs
 
#include "itkPoint.h"
#include "itkIndex.h"
 
namespace otb
{
 
namespace Functor
{
 
template <class TLabelObject, class TPolygon>
class LabelObjectToPolygonFunctor
{
public:
  typedef TLabelObject LabelObjectType;
 
  typedef typename LabelObjectType::ConstLineIterator ConstLineIteratorType;
 
  typedef typename LabelObjectType::LineType LineType;
  typedef typename LineType::IndexType       IndexType;
  typedef TPolygon                           PolygonType;
  typedef typename PolygonType::Pointer      PolygonPointerType;
  typedef typename PolygonType::VertexType   VertexType;
  typedef itk::Point<double, 2>  PointType;
  typedef itk::Vector<double, 2> SpacingType;
  typedef itk::Index<2> RegionIndexType;
 
  inline PolygonType* operator()(LabelObjectType* labelObject);
 
  const char* GetNameOfClass()
  {
    return "LabelObjectToPolygonFunctor";
  }
 
  void SetStartIndex(const RegionIndexType& index)
  {
    m_StartIndex = index;
  }
 
  const RegionIndexType& GetStartIndex() const
  {
    return m_StartIndex;
  }
 
  void SetOrigin(const PointType& origin)
  {
    m_Origin = origin;
  }
 
  const PointType& GetOrigin() const
  {
    return m_Origin;
  }
 
  void SetSpacing(const SpacingType& spacing)
  {
    m_Spacing = spacing;
  }
 
  const SpacingType& GetSpacing() const
  {
    return m_Spacing;
  }
 
  LabelObjectToPolygonFunctor()
    : m_Polygon(nullptr),
      m_CurrentState(UP_LEFT),
      m_PositionFlag(LEFT_END),
      m_StartingPoint(),
      m_CurrentPoint(),
      m_CurrentRun(),
      m_CurrentLine(0),
      m_Solution(),
      m_LineOffset(0),
      m_StartIndex(),
      m_Origin(),
      m_Spacing(1.)
  {
    m_StartingPoint.Fill(0);
    m_CurrentPoint.Fill(0);
    m_CurrentRun.Fill(0);
    m_StartIndex.Fill(0);
    m_Origin.Fill(0);
  }
 
  virtual ~LabelObjectToPolygonFunctor()
  {
  }
 
private:
  typedef std::vector<LineType>        RunsPerLineType;
  typedef std::vector<RunsPerLineType> RunsPerLineVectorType;
  typedef std::vector<IndexType>       IndexVectorType;
 
  enum StateType
  {
    UP_LEFT,
    UP_RIGHT,
    DOWN_LEFT,
    DOWN_RIGHT
  };
  enum PositionFlagType
  {
    LEFT_END,
    RIGHT_END
  };
 
  static bool LexicographicalLineCompare(const LineType& l1, const LineType& l2);
 
  inline bool IsRunIndexValid(const IndexType& index) const;
 
  inline IndexType Within(const IndexType& point, unsigned int line) const;
 
  inline IndexType LeftEnd(const IndexType& runIndex) const;
 
  inline IndexType RightEnd(const IndexType& runIndex) const;
 
  inline IndexType RightMostLeftEndInside(unsigned int line, const IndexType& point, const IndexType& run) const;
 
  inline IndexType LeftMostRightEndInside(unsigned int line, const IndexType& point, const IndexType& run) const;
 
  inline void WalkLeft(unsigned int line, const IndexType& startPoint, const IndexType& endPoint, PolygonType* polygon, const StateType state);
 
  inline void WalkRight(unsigned int line, const IndexType& startPoint, const IndexType& endPoint, PolygonType* polygon, const StateType state);
 
  // Apply origin and spacing
  VertexType IndexToPoint(const VertexType& index) const;
 
  PolygonPointerType m_Polygon;
 
  // Internal structure to store runs
  RunsPerLineVectorType m_InternalDataSet;
 
  StateType m_CurrentState;
  PositionFlagType m_PositionFlag;
 
  // The starting point for vectorization
  IndexType m_StartingPoint;
 
  IndexType m_CurrentPoint;
 
  IndexType m_CurrentRun;
 
  int m_CurrentLine;
 
  IndexVectorType m_Solution;
 
  unsigned int m_LineOffset;
 
  // The following will be used for coordinate transform
  RegionIndexType m_StartIndex;
  PointType       m_Origin;
  SpacingType     m_Spacing;
 
}; // end class LabelObjectToPolygonFunctor
 
} // end namespace Functor
 
} // end namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbLabelObjectToPolygonFunctor.hxx"
#endif
 
#endif