otbOGRLayerWrapper.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 otbOGRLayerWrapper_h
#define otbOGRLayerWrapper_h
 
// #include <iosfwd> // std::ostream&
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow"
#include <boost/iterator/iterator_facade.hpp>
#include <boost/utility/enable_if.hpp>
#pragma GCC diagnostic pop
#else
#include <boost/iterator/iterator_facade.hpp>
#include <boost/utility/enable_if.hpp>
#endif
// #include "itkIndent.h", included from field
#include "otbOGRFeatureWrapper.h"
#include <memory>
#include <string>
 
// #include "ogr_core.h" // OGRwkbGeometryType, included from feature -> field
// Forward declarations
class OGRLayer;
class OGRGeometry;
class OGRFeatureDefn;
 
namespace otb
{
namespace ogr
{
class DataSource;
class Layer;
 
OTBGdalAdapters_EXPORT bool operator==(Layer const& lhs, Layer const& rhs);
 
class OTBGdalAdapters_EXPORT Layer
{
public:
 
  typedef Layer Self;
  const char*   GetNameOfClass() const
  {
    return "Layer";
  }
 
#if 0
  typedef itk::SmartPointer<DataSource> DataSourcePtr;
#endif
 
 
  Layer(OGRLayer* layer, bool modifiable);
 
  Layer(OGRLayer* layer, GDALDataset& sourceInChargeOfLifeTime, bool modifiable);
 
 
  int GetFeatureCount(bool doForceComputation) const;
 
  void CreateFeature(Feature feature);
 
  void DeleteFeature(long nFID);
 
  Feature GetFeature(long nFID);
 
  void SetFeature(Feature feature);
 
  std::string GetName() const;
 
  OGREnvelope GetExtent(bool force = false) const;
 
  void GetExtent(double& ulx, double& uly, double& lrx, double& lry, bool force = false) const;
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const;
 
 
  struct boolean
  {
    int i;
  };
 
  operator int boolean::*() const
  {
    return m_Layer ? &boolean::i : nullptr;
  }
 
  OGRLayer& ogr();
 
 
  OGRGeometry const* GetSpatialFilter() const;
 
  void SetSpatialFilter(OGRGeometry const* spatialFilter);
 
  void SetSpatialFilterRect(double dfMinX, double dfMinY, double dfMaxX, double dfMaxY);
 
  OGRSpatialReference const* GetSpatialRef() const;
 
  std::string GetProjectionRef() const;
 
 
  template <class Value>
  class feature_iter : public boost::iterator_facade<feature_iter<Value>, Value, boost::single_pass_traversal_tag>
  {
    struct enabler
    {
    };
 
  public:
    feature_iter() : m_Layer(nullptr), m_Crt(nullptr)
    {
    }
    explicit feature_iter(otb::ogr::Layer& layer) : m_Layer(&layer), m_Crt(layer.GetNextFeature())
    {
    }
    template <class OtherValue>
    feature_iter(feature_iter<OtherValue> const& other, typename boost::enable_if<boost::is_convertible<OtherValue*, Value*>>::type* = nullptr)
      : m_Layer(other.m_Layer), m_Crt(other.m_Crt)
    {
    }
 
  private:
    friend class boost::iterator_core_access;
    template <class>
    friend class feature_iter;
 
    template <class OtherValue>
    bool equal(feature_iter<OtherValue> const& other) const
    {
      return other.m_Crt == m_Crt;
    }
    void increment()
    {
      assert(m_Layer && "cannot increment end()");
      m_Crt = m_Layer->GetNextFeature();
    }
    Value& dereference() const
    {
      return m_Crt;
    }
 
    otb::ogr::Layer* m_Layer;
    otb::ogr::Feature mutable m_Crt;
  };
 
  template <class>
  friend class feature_iter;
  typedef feature_iter<Feature> iterator;
  typedef feature_iter<Feature const> const_iterator;
 
  const_iterator cbegin() const;
 
  const_iterator cend() const
  {
    return iterator();
  }
 
  const_iterator begin() const
  {
    return cbegin();
  }
 
  const_iterator end() const
  {
    return cend();
  }
 
  iterator begin();
 
  iterator end()
  {
    return iterator();
  }
 
  const_iterator cstart_at(GIntBig index) const;
 
  const_iterator start_at(GIntBig index) const
  {
    return cstart_at(index);
  }
 
  iterator start_at(GIntBig index);
 
 
  OGRFeatureDefn& GetLayerDefn() const;
 
  void CreateField(FieldDefn const& field, bool bApproxOK = true);
 
  void DeleteField(int fieldIndex);
 
  void AlterFieldDefn(size_t fieldIndex, FieldDefn const& newFieldDefn, int nFlags);
 
  void ReorderField(size_t oldPos, size_t newPos);
 
  void ReorderFields(int* map);
 
  void SetIgnoredFields(char const** fieldNames);
 
  OGRwkbGeometryType GetGeomType() const;
 
  friend bool operator==(Layer const& lhs, Layer const& rhs)
  {
    const bool equal = lhs.m_Layer.get() == rhs.m_Layer.get();
    return equal;
  }
 
private:
  Feature GetNextFeature();
 
  std::shared_ptr<OGRLayer> m_Layer;
 
  bool m_Modifiable;
 
#if 0
  DataSourcePtr m_DataSource;
#endif
};
 
inline bool operator!=(Layer const& lhs, Layer const& rhs)
{
  return !(lhs == rhs);
}
}
} // end namespace otb::ogr
 
#ifndef OTB_MANUAL_INSTANTIATION
// #include "otbLayerWrapper.hxx"
#endif
 
#endif // otbOGRLayerWrapper_h