otbDataNode.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 otbDataNode_h
#define otbDataNode_h
 
#include "itkPoint.h"
#include "otbPolygon.h"
#include "otbObjectList.h"
#include "otbVectorDataKeywordlist.h"
 
 
#include "ogrsf_frmts.h"
#include <string>
 
namespace otb
{
typedef enum {
  ROOT                 = 0,
  DOCUMENT             = 1,
  FOLDER               = 2,
  FEATURE_POINT        = 3,
  FEATURE_LINE         = 4,
  FEATURE_POLYGON      = 5,
  FEATURE_MULTIPOINT   = 6,
  FEATURE_MULTILINE    = 7,
  FEATURE_MULTIPOLYGON = 8,
  FEATURE_COLLECTION   = 9
} NodeType;
 
template <class TPrecision = double, unsigned VDimension = 2, class TValuePrecision = double>
class DataNode : public itk::Object
{
public:
  typedef DataNode                      Self;
  typedef itk::Object                   Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
  itkTypeMacro(DataNode, Object);
 
  typedef TPrecision      PrecisionType;
  typedef TValuePrecision ValuePrecisionType;
  itkStaticConstMacro(Dimension, unsigned int, VDimension);
 
  typedef itk::Point<PrecisionType, VDimension>                                PointType;
  typedef otb::PolyLineParametricPathWithValue<ValuePrecisionType, VDimension> LineType;
  typedef typename LineType::Pointer             LinePointerType;
  typedef typename LineType::ConstPointer        LineConstPointerType;
  typedef Polygon<ValuePrecisionType>            PolygonType;
  typedef typename PolygonType::VertexListType   VertexListType;
  typedef typename VertexListType::ConstPointer  VertexListConstPointerType;
  typedef typename PolygonType::Pointer          PolygonPointerType;
  typedef typename PolygonType::ConstPointer     PolygonConstPointerType;
  typedef ObjectList<PolygonType>                PolygonListType;
  typedef typename PolygonListType::Pointer      PolygonListPointerType;
  typedef typename PolygonListType::ConstPointer PolygonListConstPointerType;
 
  //   typedef std::map<std::string, std::string>          FieldMapType;
  //   typedef std::pair<std::string, std::string>         FieldType;
 
  itkGetConstMacro(NodeType, NodeType);
  itkGetStringMacro(NodeId);
  itkSetStringMacro(NodeId);
 
  void SetNodeType(NodeType type);
 
  std::string GetNodeTypeAsString() const;
 
  PointType GetPoint() const;
 
  LinePointerType GetLine() const;
 
  PolygonPointerType GetPolygonExteriorRing() const;
 
  PolygonListPointerType GetPolygonInteriorRings() const;
 
  void SetPoint(PointType point);
 
  void SetLine(LineType* line);
 
  void SetPolygonExteriorRing(PolygonType* polygon);
 
  void SetPolygonInteriorRings(PolygonListType* polygonList);
 
  bool IsDocument() const;
 
  bool IsRoot() const;
 
  bool IsFolder() const;
 
  bool IsPointFeature() const;
 
  bool IsLineFeature() const;
 
  bool IsPolygonFeature() const;
 
  bool IsMultiPointFeature() const;
 
  bool IsMultiLineFeature() const;
 
  bool IsMultiPolygonFeature() const;
 
  bool IsCollectionFeature() const;
 
  void SetFieldAsString(const std::string& key, const std::string& value);
 
  std::string GetFieldAsString(const std::string& key) const;
 
  void SetFieldAsInt(const std::string& key, int value);
 
  int GetFieldAsInt(const std::string& key) const;
 
  void SetFieldAsDouble(const std::string& key, double value);
 
  double GetFieldAsDouble(const std::string& key) const;
 
  //   void RemoveField(const std::string& key);
 
  bool HasField(const std::string& key) const;
 
  void CopyFieldList(const DataNode* dataNode);
 
  std::vector<std::string> GetFieldList() const;
 
  double EuclideanDistanceMetric(const DataNode* node);
 
  double EuclideanDistanceMetric(const PointType point);
 
  bool Intersects(const DataNode* node);
 
  bool Within(const DataNode* node);
 
  //   void ClearFields();
 
  void Reset(const DataNode& inputNode)
  {
    this->SetNodeType(inputNode.GetNodeType());
    this->SetNodeId(inputNode.GetNodeId());
    CopyFieldList(&inputNode);
    this->m_Data = inputNode.m_Data;
  }
protected:
 
  DataNode();
 
  ~DataNode() override
  {
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  OGRGeometry* ConvertDataNodeToOGRGeometry(const DataNode* dataNode);
 
private:
  DataNode(const Self&) = delete;
  void operator=(const Self&) = delete;
//TODO Refactor modern cpp
  typedef struct
  {
    bool                   valid;
    PointType              point;
    LinePointerType        line;
    PolygonPointerType     exteriorRing;
    PolygonListPointerType interiorRings;
  } DataType;
 
  NodeType m_NodeType;
 
  std::string m_NodeId;
 
  DataType m_Data;
 
  //   FieldMapType         m_FieldMap;
};
} // end namespace
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbDataNode.hxx"
#endif
 
#endif