DqPtrsKDTree.h

// -*-c++-*-
//----------------------------------------------------------------------------
//  XC program; finite element analysis code
//  for structural analysis and design.
//
//  Copyright (C)  Luis C. Pérez Tato
//
//  This program derives from OpenSees <http://opensees.berkeley.edu>
//  developed by the  «Pacific earthquake engineering research center».
//
//  Except for the restrictions that may arise from the copyright
//  of the original program (see copyright_opensees.txt)
//  XC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or 
//  (at your option) any later version.
//
//  This software is distributed in the hope that it will be useful, but 
//  WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details. 
//
//
// You should have received a copy of the GNU General Public License 
// along with this program.
// If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------
//DqPtrsKDTree.h


#ifndef DQPTRSKDTREE_H
#define DQPTRSKDTREE_H

#include "DqPtrs.h"
#include <set>

class Pos3d;
class Vector3d;

namespace XC {
class TrfGeom;

template <class T,class KDTree>
class DqPtrsKDTree: public DqPtrs<T>
  {
    KDTree kdtree; 
  protected:
    void create_tree(void);
  public:
    typedef typename DqPtrs<T>::const_iterator const_iterator;
    typedef typename DqPtrs<T>::iterator iterator;
    typedef typename DqPtrs<T>::reference reference;
    typedef typename DqPtrs<T>::const_reference const_reference;
    typedef typename DqPtrs<T>::size_type size_type;

    DqPtrsKDTree(CommandEntity *owr= nullptr);
    DqPtrsKDTree(const DqPtrsKDTree &);
    explicit DqPtrsKDTree(const std::deque<T *> &);
    explicit DqPtrsKDTree(const std::set<const T *> &);
    DqPtrsKDTree &operator=(const DqPtrsKDTree &);
    DqPtrsKDTree &operator+=(const DqPtrsKDTree &);
    void extend(const DqPtrsKDTree &);
    //void extend_cond(const DqPtrsKDTree &,const std::string &cond);
    bool push_back(T *);
    bool push_front(T *);
    bool remove(T *);
    void clearAll(void);

    T *getNearest(const Pos3d &p);
    const T *getNearest(const Pos3d &p) const;
  };

template <class T,class KDTree>
void DqPtrsKDTree<T,KDTree>::create_tree(void)
  {
    kdtree.clear();
    for(iterator i= this->begin();i!=this->end();i++)
      {
        T *tPtr= *i;
        assert(tPtr);
        kdtree.insert(*tPtr);
      }
  }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree>::DqPtrsKDTree(CommandEntity *owr)
  : DqPtrs<T>(owr) {}

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree>::DqPtrsKDTree(const DqPtrsKDTree &other)
  : DqPtrs<T>(other)
  { create_tree(); }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree>::DqPtrsKDTree(const std::deque<T *> &ts)
  : DqPtrs<T>(ts)
  { create_tree(); }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree>::DqPtrsKDTree(const std::set<const T *> &st)
  : DqPtrs<T>()
  {
    typename std::set<const T *>::const_iterator k;
    k= st.begin();
    for(;k!=st.end();k++)
      push_back(const_cast<T *>(*k));
  }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree> &DqPtrsKDTree<T,KDTree>::operator=(const DqPtrsKDTree &other)
  {
    DqPtrs<T>::operator=(other);
    kdtree= other.kdtree;
    return *this;
  }

template <class T,class KDTree>
void DqPtrsKDTree<T,KDTree>::extend(const DqPtrsKDTree &other)
  {
    for( DqPtrsKDTree<T,KDTree>::const_iterator i= other.begin();i!=other.end();i++)
      push_back(*i);
  }
template <class T,class KDTree>
DqPtrsKDTree<T,KDTree> &DqPtrsKDTree<T,KDTree>::operator+=(const DqPtrsKDTree &other)
  {
    extend(other);
    return *this;
  }

template <class T,class KDTree>
bool XC::DqPtrsKDTree<T,KDTree>::push_back(T *t)
  {
    bool retval= DqPtrs<T>::push_back(t);
    if(retval)
      kdtree.insert(*t);
    return retval;
  }

template <class T,class KDTree>
bool XC::DqPtrsKDTree<T,KDTree>::push_front(T *t)
  {
    bool retval= DqPtrs<T>::push_front(t);
    if(retval)
      kdtree.insert(*t);
    return retval;
  }

template <class T,class KDTree>
bool XC::DqPtrsKDTree<T,KDTree>::remove(T *t)
  {
    bool retval= DqPtrs<T>::remove(t);
    if(retval)
      kdtree.erase(*t);
    return retval;
  }

template <class T,class KDTree>
void DqPtrsKDTree<T,KDTree>::clearAll(void)
  {
    DqPtrs<T>::clear();
    kdtree.clear();
  }
template <class T,class KDTree>
T *DqPtrsKDTree<T,KDTree>::getNearest(const Pos3d &p)
  {
    T *retval= const_cast<T *>(kdtree.getNearest(p));
    return retval;
  }

template <class T,class KDTree>
const T *DqPtrsKDTree<T,KDTree>::getNearest(const Pos3d &p) const
  {
    DqPtrsKDTree<T,KDTree> *this_no_const= const_cast<DqPtrsKDTree *>(this);
    return this_no_const->getNearest(p);
  }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree> operator+(const DqPtrsKDTree<T,KDTree> &a,const DqPtrsKDTree<T,KDTree> &b)
  {
    DqPtrsKDTree<T,KDTree> retval(a);
    retval+=b;
    return retval;
  }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree> operator-(const DqPtrsKDTree<T,KDTree> &a,const DqPtrsKDTree<T,KDTree> &b)
  {
    DqPtrsKDTree<T,KDTree> retval;
    for(typename DqPtrsKDTree<T,KDTree>::const_iterator i= a.begin();i!=a.end();i++)
      {
        T *n= (*i);
        assert(n);
    if(!b.in(n)) //If not in b.
      retval.push_back(n);
      }
    return retval;    
  }

template <class T,class KDTree>
DqPtrsKDTree<T,KDTree> operator*(const DqPtrsKDTree<T,KDTree> &a,const DqPtrsKDTree<T,KDTree> &b)
  {
    DqPtrsKDTree<T,KDTree> retval;
    for(typename DqPtrsKDTree<T,KDTree>::const_iterator i= a.begin();i!=a.end();i++)
      {
        T *n= (*i);
        assert(n);
    if(b.in(n)) //If also in b.
      retval.push_back(n);
      }
    return retval;    
  }

} //end of XC namespace
#endif