otbDataNode.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 __otbDataNode_h
#define __otbDataNode_h

#include "itkPoint.h"
#include "otbPolyLineParametricPathWithValue.h"
#include "otbPolygon.h"
#include "otbObjectList.h"
#include "otbVectorDataKeywordlist.h"

#include <iostream>

#include "ogrsf_frmts.h"

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;

  // /**
  //  * Remove the field associated with the given key, if possible.
  //  * \param key The name of the field.
  //  */
  //   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 EuclideanDistance(const DataNode* node);

  double EuclideanDistance(const PointType point);

  bool Intersects(const DataNode* node);

  bool Within(const DataNode* node);

//   void ClearFields();

protected:
  DataNode();
  virtual ~DataNode() {}
  void PrintSelf(std::ostream& os, itk::Indent indent) const;

  OGRGeometry* ConvertDataNodeToOGRGeometry(const DataNode* dataNode);

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

  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.txx"
#endif

#endif