query_point.hpp

Go to the documentation of this file.

#ifndef _QUERY_POINT_HPP
#define _QUERY_POINT_HPP

#include <CGAL/Kd_tree.h>
#include <CGAL/Fuzzy_iso_box.h>
#include <CGAL/Search_traits.h>
#include "function_output_iterator.hpp"
#include "global.hpp"
#include "geometry.hpp"

namespace Arak {

  class QueryPointListener {

  public:

    QueryPointListener() { }

    virtual void recolor(Color color) = 0;

  }; // end of class: QueryPointListener

  typedef std::list<QueryPointListener*> QueryPointListenerList;

  class QueryPoint : public Geometry::Point {

  protected:

    QueryPointListenerList* listeners;

    Color* c;

  public:

    QueryPoint(const Geometry::Point& p,
         QueryPointListenerList* listeners,
         Color* color) 
      : Geometry::Point(p), listeners(listeners), c(color) { }

    QueryPoint(const Geometry::Point p = CGAL::ORIGIN) 
      : Geometry::Point(p), listeners(NULL), c(NULL){ }

    Color color() const { return *c; }

    void setColor(Color color) const {
      if (color != *c) {
  *c = opposite(color);
  recolor();
      }
    }

    void recolor() const {
      *c = opposite(*c);
      typedef QueryPointListenerList::iterator Iterator;
      for (Iterator it = listeners->begin(); it != listeners->end(); it++) {
  QueryPointListener* listener = *it;
  listener->recolor(*c);
      }
    }

    void addListener(QueryPointListener* listener) const {
      listener->recolor(*c);
      listeners->push_front(listener);
    }

  }; // end of class: QueryPoint

  class QueryPointListenerFactory {

  public:

    virtual QueryPointListener* create(const QueryPoint& q) = 0;

  };

  class QueryPointIndex {

  protected:

    std::vector<QueryPoint> qpoints;

    QueryPointListenerList* listenerLists;

    Color* color;

    class SearchTraits {
    public:
      typedef Geometry::Kernel K;
      typedef Arak::QueryPoint Point_d;
      typedef K::Iso_rectangle_2 Iso_box_d;
      typedef K::Circle_2 Sphere_d;
      typedef K::Cartesian_const_iterator_2 Cartesian_const_iterator_d;
      typedef K::Construct_cartesian_const_iterator_2 Construct_cartesian_const_iterator_d;
      
      typedef K::Construct_min_vertex_2 Construct_min_vertex_d;
      typedef K::Construct_max_vertex_2 Construct_max_vertex_d;
      typedef K::Construct_center_2 Construct_center_d;
      typedef K::Compute_squared_radius_2 Compute_squared_radius_d;
      
      typedef K::Construct_iso_rectangle_2 Construct_iso_box_d;
      typedef K::FT FT;
    };

    typedef CGAL::Kd_tree<SearchTraits> KDTree;

    KDTree* tree;

    friend class RecolorTriangleFunction {

    private:

      const Geometry::Triangle* t;

    public:

      RecolorTriangleFunction(const Geometry::Triangle& t) : t(&t) { }

      void operator() (const QueryPoint& q) {
  if (!t->has_on_unbounded_side(q)) q.recolor();
      }
    };

    friend class RecolorQuadrilateralFunction {

    private:

      const Geometry::Triangle *t1;

      const Geometry::Triangle *t2;

    public:

      RecolorQuadrilateralFunction(const Geometry::Triangle& t1,
           const Geometry::Triangle& t2) 
  : t1(&t1), t2(&t2) { }

      void operator() (const QueryPoint& q) {
  if (!t1->has_on_unbounded_side(q)) q.recolor();
  if (!t2->has_on_unbounded_side(q)) q.recolor();
      }
    };

  public:

    template <class QueryPointListenerType>
    QueryPointIndex(const std::vector<Geometry::Point>& points,
        const std::vector<QueryPointListenerType*>& listeners) {
      // Allocate the color variables and listener lists
      int n = points.size();
      color = new Color[n];
      listenerLists = new QueryPointListenerList[n];
      // Create the query points.
      qpoints.reserve(n);
      for (int i = 0; i < n; i++) {
  color[i] = INVALID_COLOR;
  QueryPoint q(points[i], &(listenerLists[i]), &(color[i]));
  qpoints.push_back(q);
  q.addListener(listeners[i]);
      }
      // Initialize the KD tree.
      tree = new KDTree(qpoints.begin(), qpoints.end());
    }

    QueryPointIndex(const Geometry::Rectangle& r, int rows, int cols);

    QueryPointIndex(const QueryPointIndex& q1, 
        const QueryPointIndex& q2);

    ~QueryPointIndex();

    void addListeners(QueryPointListenerFactory& factory);

    template <class OutputIterator>
    void output(const Geometry::Rectangle& r, OutputIterator it) const {
      using namespace Geometry;
      typedef CGAL::Fuzzy_iso_box<SearchTraits> FuzzyBox;
      FuzzyBox box(r.min(), r.max());
      tree->search(it, box);
    }

    template <class UnaryFunction>
    void apply(const Geometry::Rectangle& r, UnaryFunction& f) const {
      output(r, boost::make_function_output_iterator(f));
    }

    template <class UnaryFunction>
    void applyToAll(UnaryFunction& f) const {
      tree->report_all_points(boost::make_function_output_iterator(f));
    }

    int size() const { return qpoints.size(); }

    const QueryPoint& point(int i) const { return qpoints[i]; }

    QueryPoint& point(int i) { return qpoints[i]; }
    
    const QueryPoint& closest(const Geometry::Point& p) const;

    void recolor(const Geometry::Point& a,
     const Geometry::Point& b,
     const Geometry::Point& c);

    void recolor(const Geometry::Point& a,
     const Geometry::Point& b,
     const Geometry::Point& c,
     const Geometry::Point& d);

  }; // end of class: QueryPointIndex
  
}

#endif

---