featureDuplicateRemover.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>

#pragma once

namespace MAKVRinTerra
{
   class DtGeometryDuplicateRemover
   {
   public:
      typedef boost::unordered_set<DtFeatureGeometry::Hash> HashSet;

      bool has(DtFeatureGeometry g) const
      {
         return myHashSet.find(g.hash()) != myHashSet.end();
      }

      bool insert(DtFeatureGeometry g)
      {
         HashSet::iterator iter;
         bool inserted;
         boost::tie(iter, inserted) = myHashSet.insert(g.hash());

         return inserted;
      }

   protected:
      HashSet myHashSet;
   };

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

      DtFeatureDuplicateRemover(ForEachFunction func = ForEachFunction())
         : myFunc(func)
      {
      }

      void setFunction(ForEachFunction func)
      {
         myFunc = func;
      }

      bool isDuplicate(const F& feature) const
      {
         return !const_cast<DtFeatureDuplicateRemover*>(this)->insert(feature.geometry());
      }

      void operator()(const F& feature)
      {
         if (!isDuplicate(feature) && myFunc)
            myFunc(feature);
      }

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

   protected:
      ForEachFunction myFunc;
   };

   template <typename FS>
   class DtDeduplicatingFeatureSet : public FS::ScopedWrapper
   {
   public:
      typedef typename FS::ScopedWrapper Parent;
      typedef typename FS::Feature Feature;
      typedef typename FS::ForEachFunction ForEachFunction;

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

      void forEachFeature(ForEachFunction func, DtWaitType wait) const
      {
         DtFeatureDuplicateRemover<Feature> dedupe(func);
         Parent::forEachFeature(boost::ref(dedupe), wait);
      }

      void forEachFeatureParallel(ForEachFunction func, DtWaitType wait) const
      {
         forEachFeature(func, wait);
      }

      DtDeduplicatingFeatureSet* filter(const DtQuery& query, DtLoadType load) const
      {
         return new DtDeduplicatingFeatureSet(Parent::filter(query, load));
      }

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

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