qt_triangulation_2.h

很多二维 三维几何计算算法 C++ 类库

// Copyright (c) 2005  Stanford University (USA).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.3-branch/Kinetic_data_structures/include/CGAL/Kinetic/IO/Qt_triangulation_2.h $
// $Id: Qt_triangulation_2.h 40020 2007-08-23 17:05:31Z drussel $
// 
//
// Author(s)     : Daniel Russel <[e-mail]>

#ifndef CGAL_KINETIC_IO_QT_TRIANGULATION_2_H
#define CGAL_KINETIC_IO_QT_TRIANGULATION_2_H

#include <CGAL/IO/Qt_widget.h>
#include <CGAL/Kinetic/Ref_counted.h>
#include <CGAL/Kinetic/internal/tds_2_helpers.h>
#include <CGAL/Kinetic/Delaunay_triangulation_recent_edges_visitor_2.h>

CGAL_KINETIC_BEGIN_NAMESPACE

//! This class draws a Kinetic_Delaunay_2 triangulation to a Qt_gui_2.
/*!  The most recently created edges are colored green and the other
  edges are colored black. See kinetic_Delaunay_2.cc for a useage
  example. There are no public methods other than the constructor.
*/
template <class KDel, class IK, class Qt_gui>
class Qt_triangulation_2: public Ref_counted<Qt_triangulation_2<KDel, IK, Qt_gui> >
{
  typedef Qt_triangulation_2<KDel, IK, Qt_gui> This;
  // in icc Qt_gui::Listener::This captures This so I need to change the name
  //typedef This Qt_tri;;
  typedef typename KDel::Triangulation Triangulation;
  typedef internal::Triangulation_data_structure_helper_2<typename Triangulation::Triangulation_data_structure> TDS_helper;

  typedef typename Triangulation::Edge Edge;

  // maybe icl wants the class definition before the useage. 
  typedef typename Qt_gui::Listener QTL;
  class Listener: public QTL
  {
    typedef Qt_triangulation_2<KDel, IK, Qt_gui> Container;
    typedef QTL P;
  public:
    Listener(typename Qt_gui::Handle &h, Container *t): P(h), t_(t){}
    virtual void new_notification(typename P::Notification_type nt) {
      if (nt == P::PICTURE_IS_VALID) {
        t_->draw(*P::widget(), P::notifier()->current_time());
      }
    }
  protected:
    Container *t_;
  };
  friend class Listener;

public:
  //typedef Kinetic_Delaunay Kinetic_Delaunay;
  //typedef CGAL::Ref_counted_pointer<This> Pointer;

  Qt_triangulation_2(typename KDel::Handle kdel,
                     IK ik,
                     typename Qt_gui::Handle gui): listener_(gui, this),
                                                   ik_(ik),
                                                   kdel_(kdel) {
  }

protected:

  //! This class listens for redraw requests (PICTURE_IS_VALID becoming false)
  /*!
    It calls the draw method when it recieves a notification.
  */

  template <class V>
  void set_color(const Edge &e, CGAL::Qt_widget &w, const V &) const {
    if (!kdel_->has_event(e)) {
      w << CGAL::Color(125,125,125);
    } else if (kdel_->has_finite_event(e)){
      w << CGAL::Color(255,0,0);
    } else {
      w << CGAL::Color(0,0,0);
    }
  }

  typedef Delaunay_triangulation_recent_edges_visitor_2<typename KDel::Triangulation> REV;

  void set_color(const Edge &e, CGAL::Qt_widget &w,
                 const REV& ) const {
    w << CGAL::LineWidth(2);
    if (!kdel_->has_event(e)) {
      w << CGAL::Color(125,125,125);
    } else if (kdel_->visitor().contains(e) || kdel_->visitor().contains(TDS_helper::mirror_edge(e))) {
      w<< CGAL::Color(0,255,0);
    } else if (kdel_->has_finite_event(e)){
      w << CGAL::Color(125,125,125);
    } else {
      w << CGAL::Color(0,0,0);
    }
  }

  //! Draw the triangulation.
  void draw( CGAL::Qt_widget &w, double t) const
  {
   
    
    const Triangulation  &tri= kdel_->triangulation();
    ik_.set_time(typename IK::Time(t));
    typedef typename IK::Static_kernel::Point_2 Static_point;
    typedef typename IK::Static_kernel::Segment_2 Static_segment;
    w << CGAL::LineWidth(1);
    // << CGAL::FillColor(CGAL::Color(0,0,0));
    if (tri.dimension() != 2) return;
    ik_.set_time(typename IK::NT(t));
    typename IK::Current_coordinates cc= ik_.current_coordinates_object();
    for (typename Triangulation::Finite_edges_iterator fit = tri.finite_edges_begin();
         fit != tri.finite_edges_end(); ++fit) {
      Static_point p0= cc(fit->first->vertex((fit->second+1)%3)->point());
      Static_point p1= cc(fit->first->vertex((fit->second+2)%3)->point());
      Static_segment ss(p0, p1);
      set_color(*fit, w, kdel_->visitor());
      w << ss;
    }
  }

  Listener listener_;
  IK ik_;
  typename KDel::Handle kdel_;
};

CGAL_KINETIC_END_NAMESPACE
#endif