geometryDuplicateRemover.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#include <features/featureGeometry.h>

#include <boost/unordered/unordered_set.hpp>
#include <boost/tuple/tuple.hpp>

#include <tbb/spin_mutex.h>

#include <vrfutil/objectCounter.h>

#pragma once

#include <features/featuresDefines.h>
namespace MAKVRinTerra
{
   class DT_DLL_features DtGeometryDuplicateRemover
#ifdef DtObjectDebugger_Enable
      : public DtObjectDebugger<DtGeometryDuplicateRemover>
#endif
   {
   public:
      typedef boost::unordered_set<DtFeatureGeometry::Hash> HashSet;

      bool has(const DtFeatureGeometry& g) const
      {
         Mutex::scoped_lock lock(myMutex);
         return myHashSet.find(g.hash()) != myHashSet.end();
      }

      bool insert(const DtFeatureGeometry& g)
      {
         return insert(g.hash());
      }

      bool insert(const std::string& h)
      {
         HashSet::iterator iter;
         bool inserted;

         Mutex::scoped_lock lock(myMutex);
         boost::tie(iter, inserted) = myHashSet.insert(h);

         return inserted;
      }

   protected:
      typedef tbb::spin_mutex Mutex;
      mutable Mutex myMutex;

      HashSet myHashSet;
   };

   template <typename F>
   class DtFeatureDuplicateRemover : public DtGeometryDuplicateRemover
   {
   public:
      typedef boost::function<void (const F&)> ForEachFunction;

      DtFeatureDuplicateRemover() : myFunc() { }

      explicit DtFeatureDuplicateRemover(const ForEachFunction& func)
         : myFunc(func)
      {
         assert(myFunc);
      }

      bool isDuplicate(const F& feature)
      {
         boost::optional<std::string> attr = feature.template attributeAs<std::string>("MAK_FID");
         
         if (attr)
         {
            if (attr->empty())
               return false;

            return !insert(*attr);
         }

         return !insert(feature.geometry());
      }

      void operator()(const F& feature) const
      {
         if (!const_cast<DtFeatureDuplicateRemover*>(this)->isDuplicate(feature))
            myFunc(feature);
      }

      void call(ForEachFunction func, const F& feature)
      {
         if (!isDuplicate(feature))
            func(feature);
      }

   protected:
      ForEachFunction myFunc;
   };

   template <typename F>
   class DtSharedFeatureDuplicateRemover
#ifdef DtObjectDebugger_Enable
      : public DtObjectDebugger< DtSharedFeatureDuplicateRemover<F> >
#endif
   {
   public:
      typedef boost::function<void (const F&)> ForEachFunction;

      typedef boost::shared_ptr<DtFeatureDuplicateRemover<F> > BasePtr;

      explicit DtSharedFeatureDuplicateRemover(const ForEachFunction& func)
         : myRemover(new DtFeatureDuplicateRemover<F>(func))
      {
      }

      bool isDuplicate(const F& feature)
      {
         return myRemover->isDuplicate(feature);
      }

      void operator()(const F& feature) const
      {
         (*myRemover)(feature);
      }

      void call(ForEachFunction func, const F& feature) const
      {
         myRemover->call(func, feature);
      }

      DtSharedFeatureDuplicateRemover(const BasePtr& r)
         : myRemover(r) 
      {
         assert(myRemover);
      }

   private:
      BasePtr myRemover;
   };

   template <typename FS>
   class DtDeduplicatingFeatureSet
      : public FS::ScopedWrapper
#ifdef DtObjectDebugger_Enable
      , public DtObjectDebugger< DtDeduplicatingFeatureSet<FS> >
#endif
   {
   public:
      typedef typename FS::ScopedWrapper Parent;
      typedef typename FS::Feature Feature;
      typedef typename FS::ForEachFunction ForEachFunction;

      explicit DtDeduplicatingFeatureSet(FS* fs)
         : Parent(fs)
      {
      }

      void forEachFeatureParallel(const ForEachFunction& func) const
      {
         DtFeatureDuplicateRemover<Feature> dedupe(func);
         Parent::forEachFeatureParallel(std::ref(dedupe));     
      }

      typename FS::DetachCallback forEachFeatureAsync(const ForEachFunction& func) const
      {
         return Parent::forEachFeatureAsync(func);
      }

      FS* filter(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geom,
         DtLoadType load) const
      {
         std::auto_ptr<FS> fs(Parent::filter(query, geom, load));
         if (!fs.get())
            return 0;

         return new DtDeduplicatingFeatureSet(fs.release());
      }

      DtDeduplicatingFeatureSet* clone() const
      {
         return new DtDeduplicatingFeatureSet(*this);
      }

   protected:
      DtDeduplicatingFeatureSet(const DtDeduplicatingFeatureSet& fs)
         : Parent(fs.getPtr()->clone())
      {
      }
   };
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtGeometryDuplicateRemover);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtSharedFeatureDuplicateRemover);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtDeduplicatingFeatureSet);