// Copyright (c) 2005  Tel-Aviv University (Israel).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you may redistribute it under
// the terms of the Q Public License version 1.0.
// See the file LICENSE.QPL 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.
//
// $Source: /CVSROOT/CGAL/Packages/Envelope_3/include/CGAL/Envelope_element_visitor_3.h,v $
// $Revision$ $Date$
// $Name:  $
//
// Author(s)     : Michal Meyerovitch     <gorgymic@post.tau.ac.il>

#ifndef CGAL_ENVELOPE_ELEMENT_VISITOR_3_H
#define CGAL_ENVELOPE_ELEMENT_VISITOR_3_H

#include <CGAL/Object.h>
#include <CGAL/enum.h>
#include <CGAL/Unique_hash_map.h>
#include <CGAL/Arr_observer.h>
#include <CGAL/Arr_accessor.h>
#include <CGAL/Arr_walk_along_line_point_location.h>
#include <CGAL/Arr_naive_point_location.h>
#include <CGAL/Arrangement_2/Arr_inc_insertion_zone_visitor.h>
#include <CGAL/Arrangement_2_incremental_insert.h>
#include <CGAL/Timer.h>
#include <CGAL/utility.h>

#include <vector>
#include <algorithm>
#include <iostream>
#include <deque>

CGAL_BEGIN_NAMESPACE

// this class does the resolving of edge and face in the divide & conquer algorithm
// it should handle all faces (it supports holes in the face)

template <class EnvelopeTraits_3, class MinimizationDiagram_2>
class Envelope_element_visitor_3
{
public:
  typedef EnvelopeTraits_3                             Traits;
  typedef typename Traits::Surface_3                   Surface_3;
  typedef typename Traits::Xy_monotone_surface_3       Xy_monotone_surface_3;

  typedef MinimizationDiagram_2                        Minimization_diagram_2;
  typedef typename Traits::Point_2                     Point_2;
  typedef typename Traits::X_monotone_curve_2          X_monotone_curve_2;
  typedef typename Traits::Curve_2                     Curve_2;

protected:

  typedef Envelope_element_visitor_3<Traits, Minimization_diagram_2> Self;
  typedef typename Minimization_diagram_2::Halfedge_const_iterator  Halfedge_const_iterator;
  typedef typename Minimization_diagram_2::Halfedge_handle          Halfedge_handle;
  typedef typename Minimization_diagram_2::Halfedge_iterator        Halfedge_iterator;
  typedef typename Minimization_diagram_2::Face_handle              Face_handle;
  typedef typename Minimization_diagram_2::Face_iterator            Face_iterator;
  typedef typename Minimization_diagram_2::Vertex_handle            Vertex_handle;
  typedef typename Minimization_diagram_2::Vertex_iterator          Vertex_iterator;
  typedef typename Minimization_diagram_2::Ccb_halfedge_circulator  Ccb_halfedge_circulator;
  typedef typename Minimization_diagram_2::Hole_iterator            Hole_iterator;
  typedef typename Minimization_diagram_2::Isolated_vertex_iterator Isolated_vertex_iterator;
  typedef typename Minimization_diagram_2::Dcel                     Dcel;
  typedef typename Minimization_diagram_2::Dcel::Dcel_data_iterator Envelope_data_iterator;

  typedef Arr_observer<Minimization_diagram_2>                      Md_observer;
  typedef Arr_accessor<Minimization_diagram_2>                      Md_accessor;
  
  typedef Arr_walk_along_line_point_location<Minimization_diagram_2>
                                                                    Md_point_location;

  typedef Arr_inc_insertion_zone_visitor<Minimization_diagram_2>    Md_insert_zone_visitor;
  
  typedef std::list<Halfedge_handle>                                Halfedges_list;
  typedef typename std::list<Halfedge_handle>::iterator             Halfedges_list_iterator;

  typedef std::pair<Halfedge_handle, Intersection_type>             Halfedge_w_type;
  typedef std::list<Halfedge_w_type>                                Halfedges_w_type_list;

  typedef std::list<Vertex_handle>                                  Vertices_list;
  typedef typename std::list<Vertex_handle>::iterator               Vertices_list_iterator;

  typedef std::list<Face_handle>                                    Faces_list;
  typedef typename std::list<Face_handle>::iterator                 Faces_list_iterator;

  typedef Unique_hash_map<Vertex_handle, bool>                      Vertices_hash;
  typedef Unique_hash_map<Halfedge_handle, bool>                    Halfedges_hash;
  typedef Unique_hash_map<Halfedge_handle, Intersection_type>       Halfedges_hash_w_type;
  typedef Unique_hash_map<Face_handle, bool>                        Faces_hash;

  typedef Unique_hash_map<Vertex_handle, Vertex_handle>             Vertices_map;
  typedef Unique_hash_map<Halfedge_handle, Halfedge_handle>         Halfedges_map;
  typedef Unique_hash_map<Face_handle, Face_handle>                 Faces_map;

  typedef Unique_hash_map<Vertex_handle, Halfedge_handle>           Vertices_to_edges_map;
  
  typedef std::pair<Curve_2, Intersection_type>                     Intersection_curve;
  typedef std::list<Object>                                         Intersections_list;

  // this is used in the resolve edge process
  typedef Triple<Point_2, bool, bool>                               Point_2_with_info;
  struct Points_compare
  {
    protected:
      Traits* p_traits;
    public:
      Points_compare(Traits& tr) : p_traits(&tr)
      {}

      bool operator() (const Point_2_with_info& p1,
                       const Point_2_with_info& p2) const
      {
        Comparison_result res =
          p_traits->compare_xy_2_object()(p1.first, p2.first);
        if (res == SMALLER)
          return true;
        if (res == LARGER)
          return false;
        return (p1.second == true || p2.third == true);
      }
  };
  
public:
  // c'tor
  Envelope_element_visitor_3()
  {
    // Allocate the traits.
    traits = new Traits;
    own_traits = true;

    reset_statistics();
  }

  Envelope_element_visitor_3(Traits* tr)
  {
    // Set the traits.
    traits = tr;
    own_traits = false;

    reset_statistics();
  }

  // virtual destructor.
  virtual ~Envelope_element_visitor_3()
  {
    // Free the traits object, if necessary.
    if (own_traits)
      delete traits;
  }

  // get a face with 2 surfaces defined over it, and compute the arrangement of the
  // envelope of these surfaces over the face
  void resolve(Face_handle face, Minimization_diagram_2& result)
  {
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "in general resolve face" << std::endl;                                  
    #endif

    CGAL_assertion(face->get_aux_is_set(0));
    CGAL_assertion(face->get_aux_is_set(1));
    
    intersection_timer.start();
    // we are interested with the envelope's shape over the current face,
    // so we only need to check the first surface from each group, since
    // all the surfaces in a group overlap over the current face.
    Xy_monotone_surface_3 surf1 = get_aux_surface(face, 0);
    Xy_monotone_surface_3 surf2 = get_aux_surface(face, 1);
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "compared surfaces are:" << surf1 << std::endl << surf2 << std::endl;
    #endif

    // find the projected intersections of the surfaces. if none - we have a simple case:
    // need only resolve non-intersecting and return
    std::list<Object> inter_objs;
    get_projected_intersections(surf1, surf2, std::back_inserter(inter_objs));
    intersection_timer.stop();

    if (inter_objs.size() == 0)
    {
      minimal_face_timer.start();
      // here for resolve we can compare the surfaces over the edges only (no need for left/right versions)
      Comparison_result cur_res = resolve_minimal_face(face);
      copy_data_by_comparison_result(face, face, cur_res);
      // check face boundary for "data from face" features
      #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
        copy_data_to_face_boundary(face);
      #endif
      minimal_face_timer.stop();
      return;
    }
    
    copied_arr_timer.start();
    // we insert all projected intersections into a temporary arrangement,
    // with only the current face's curves, to find the arrangement of the lower envelope
    // of the 2 surfaces over the current face
    Minimization_diagram_2 copied_face_arr(traits);

    // here we maintain a mapping between edges in the copied arrangement and
    // their original generating edge from result
    Halfedges_map map_copied_to_orig_halfedges;
    // here we maintain a mapping between vertices in the copied arrangement and
    // their original generating vertex from result
    Vertices_map  map_copied_to_orig_vertices;
    // here we maintain a mapping between faces in the copied arrangement and
    // their corresponding face from result
    Faces_map     map_copied_to_orig_faces;

    // now, insert the face's boundary into the temporary minimization diagram
    // the face is assumed to have outer boundary, and may also have holes,
    // and isolated vertices
    // we need to keep track of the original halfedges in the inserted halfedges
    // we also need to have the face handle of the copied face in copied_face_arr
    bool fakes_exist = false;
    Face_handle copied_face = copy_face(face, result, copied_face_arr,
                                        map_copied_to_orig_halfedges,
                                        map_copied_to_orig_vertices,
                                        fakes_exist);
    CGAL_assertion(is_valid(copied_face_arr));
    map_copied_to_orig_faces[copied_face] = face;
    copied_arr_timer.stop();
    
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "number of face's edges: " << copied_face_arr.number_of_edges() << std::endl;
    #endif
    
    // insert the projected intersections into the temporary minimization diagram
    zone_timer.start();
    Point_2 point;
    Intersection_curve curve;
    Object cur_obj;
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "resolve face: need to deal with " << inter_objs.size()
                << " intersection objects" << std::endl;
    #endif

    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      // print all edges of result
      std::cout << "from general resolve face: all edges before insert " << std::endl;
      for (Halfedge_iterator hhit = result.halfedges_begin();
           hhit != result.halfedges_end(); ++hhit, ++hhit)
        std::cout << hhit->curve() << std::endl;
    #endif
    
    // we use our zone visitor, which only inserts into the arrangement the
    // points and curves which are inside the copied face
    // it updates the result arrangement at the same time (action after action
    // using observer to the copied arrangement and accessor to result)
    // the visitor is responsible for updating:
    // 1. the collection of special edges. (these are (parts of) edges of the

    //    original face's boundary that overlap with projected intersections
    Halfedges_list result_special_edges;
    // 2. the collection of newly added edges, each with the type of the
    //    projected intersection that created it.
    Halfedges_w_type_list result_new_edges;
    // 3. the collection of faces that form the face before any insertion
    Faces_list     result_face_parts;
    // 4. the collection of special vertices, which contains:
    //    - new vertices that were created inside the original face
    //      (both isolated and not isolated)
    //    - new vertices created by a split of a boundary edge which has
    //      the property "data from face"
    //    - original vertices of the boundary that consolidate with projected
    //      intersections, and have common aux data with the face
    //    all these vertices should have their data set as "EQUAL"
    Vertices_list  result_special_vertices;

    New_faces_observer new_faces_obs(result);    
    Copied_face_zone_visitor zone_visitor(result, copied_face_arr,
                                          face,
                                          copied_face,
                                          map_copied_to_orig_halfedges,
                                          map_copied_to_orig_vertices,
                                          map_copied_to_orig_faces,
                                          result_special_edges,
                                          result_new_edges,
                                          result_face_parts,
                                          result_special_vertices,
                                          this);

    Md_point_location pl(copied_face_arr);
    std::list<Object>::iterator inter_objs_it = inter_objs.begin();
    for(; inter_objs_it != inter_objs.end(); ++inter_objs_it)
    {
      cur_obj = *inter_objs_it;
      CGAL_assertion(!cur_obj.is_empty());
      if (assign(point, cur_obj))
      {
        // intersection can be a point when the surfaces only touch each other.
        // we are only interested in the points that are inside the face or on its
        // boundary.
        // we insert the point into the planar map as a vertex, with both surfaces
        // over it.
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "found intersection point: " << point << std::endl;
        #endif
        // should use observer for split_edge
        // if not in a sub-face of "face", shouldn't insert it
        // the above information is available in zone_visitor
        insert_point(copied_face_arr, point, pl, zone_visitor);
      }
      else if (assign(curve, cur_obj))
      {
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "found intersection curve: " << curve.first << std::endl;
        #endif
        zone_visitor.set_current_intersection_type(curve.second);
        insert_curve(copied_face_arr, curve.first, pl, zone_visitor);
      }
      else
        CGAL_assertion_msg(false, "wrong projected intersection type");
    }

    zone_visitor.finish();
    zone_timer.stop();

    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "number of new edges: "
                << result_new_edges.size() << std::endl;
    #endif
 
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "number of edges on face boundary that overlap projected intersections is "
                << result_special_edges.size() << std::endl;
    #endif
       
    // now determine the envelope data in result over the new faces
    minimal_face_timer.start();

    // first, we try to copy information from incident faces, thru fake edges
    if (fakes_exist)
    {
      typename std::list<Face_handle>::iterator fit;
      for(fit = result_face_parts.begin();
          fit != result_face_parts.end(); ++fit)
      {
        Face_handle new_f = *fit;
        // we didn't set envelope data yet
        CGAL_assertion(!new_f->is_decision_set());
        // try to find a fake edge on the outer boundary
        // (if we have fake edges, we don't have holes)
        Ccb_halfedge_circulator hec = new_f->outer_ccb();
        Ccb_halfedge_circulator hec_begin = hec;
        do {
          Halfedge_handle hh = hec;
          if (hh->get_is_fake() &&
              hh->twin()->face()->is_decision_set())
          {
            Face_handle twin_f = hh->twin()->face();
            new_f->set_decision(twin_f->get_decision());
	    
      	    hh->set_decision(twin_f->get_decision());
      	    hh->twin()->set_decision(hh->get_decision());
          }
          ++hec;
        } while (hec != hec_begin);
      }
    }
    
    // in order to use resolve_minimal_face with intersection halfedge, we go over
    // the new edges, and set data over their faces
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "number of new edges: " << result_new_edges.size() << std::endl;
    #endif
    typename Halfedges_w_type_list::iterator new_edge_it;
    for(new_edge_it = result_new_edges.begin();
        new_edge_it != result_new_edges.end(); ++new_edge_it)
    {
      Halfedge_handle new_he = (*new_edge_it).first;
      Halfedge_handle new_he_twin = new_he->twin();
      Intersection_type itype = (*new_edge_it).second;

      // set sources of the new edge
      new_he->set_aux_source(0, face->get_aux_source(0));
      new_he->set_aux_source(1, face->get_aux_source(1));
      new_he_twin->set_aux_source(0, face->get_aux_source(0));
      new_he_twin->set_aux_source(1, face->get_aux_source(1));

      // set data on new edges
      new_he->set_decision(EQUAL);
      new_he_twin->set_decision(EQUAL);
      
      // set data on the faces
      // could be that the data is set for f2, and can use itype to conclude
      // to f1, not only the opposite
      Face_handle f1 = new_he->face(), f2 = new_he_twin->face();
      Comparison_result res;
      if (!f1->is_decision_set() && !f2->is_decision_set())
      {
        res = resolve_minimal_face(f1, &new_he);
        copy_data_by_comparison_result(face, f1, res);
      }

      // now at least one of the faces f1,f2 has its decision set.      

      // if the other face doesn't have its data, we resolve it using
      // the former result and the intersection type (if exists)
      if (!f2->is_decision_set())
      {
        #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
          if (itype != UNKNOWN)
          {
            res = convert_decision_to_comparison_result(f1->get_decision());
            res = resolve_by_intersection_type(res, itype);
            CGAL_expensive_assertion_code(
              Comparison_result tmp_res = resolve_minimal_face(f2, &new_he_twin);
            );
            CGAL_expensive_assertion(tmp_res == res);
          }
          else
            res = resolve_minimal_face(f2, &new_he_twin);
        #else
          res = resolve_minimal_face(f2, &new_he_twin);
        #endif
        copy_data_by_comparison_result(face, f2, res);
      }
      if (!f1->is_decision_set())
      {
        #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
          if (itype != UNKNOWN)
          {
            res = convert_decision_to_comparison_result(f2->get_decision());
            res = resolve_by_intersection_type(res, itype);
            CGAL_expensive_assertion_code(
              Comparison_result tmp_res = resolve_minimal_face(f1, &new_he);
            );
            CGAL_expensive_assertion(tmp_res == res);
          }
          else
            res = resolve_minimal_face(f1, &new_he);
        #else
          res = resolve_minimal_face(f1, &new_he);
        #endif
        copy_data_by_comparison_result(face, f1, res);
      }

    }
    
    // we also need to check the faces incident to the halfedges in special_edges
    // since the envelope data over them should be computed using compare_left/right versions
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "number of special edges: " << result_special_edges.size()
                << std::endl;
    #endif
    Halfedges_list_iterator special_edge_it;
    for(special_edge_it = result_special_edges.begin();
        special_edge_it != result_special_edges.end(); ++special_edge_it)
    {
      // we assume that the halfedge given points to the correct face (which is inside the original face)
      Halfedge_handle special_he = *special_edge_it;
      Face_handle f = special_he->face();
      if (!f->is_decision_set())
      {
        Comparison_result res = resolve_minimal_face(f, &special_he);
        copy_data_by_comparison_result(face, f, res);      
      }

      // take care for the edge, if necessary
      if (!special_he->is_decision_set() &&
          can_copy_decision_from_face_to_edge(special_he))
      {
        if (!special_he->get_aux_is_set(0) || !special_he->get_aux_is_set(1))
        {
          // this can only happen when the edge is fake, since the edge is on 
		  // the face's boundary
          CGAL_assertion(special_he->get_is_fake());
          special_he->set_aux_source(0, face->get_aux_source(0));
          special_he->set_aux_source(1, face->get_aux_source(1));
          special_he->twin()->set_aux_source(0, face->get_aux_source(0));
          special_he->twin()->set_aux_source(1, face->get_aux_source(1));
	      }
      	if (special_he->get_is_fake())
      	{
      	  // this edge is not fake anymore, as it coincides with a projected
      	  // intersection
      	  special_he->set_is_fake(false);
      	  special_he->twin()->set_is_fake(false);
        }
        special_he->set_decision(EQUAL);
        special_he->twin()->set_decision(EQUAL);
      }
    }

    // update data on special vertices
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "number of special vertices: " << result_special_vertices.size() << std::endl;
    #endif
    Vertices_list_iterator special_vertex_it;
    for(special_vertex_it = result_special_vertices.begin();
        special_vertex_it != result_special_vertices.end(); ++special_vertex_it)
    {
      Vertex_handle special_v = *special_vertex_it;
      if (!special_v->is_decision_set())
      {
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "special vertex " << special_v->point() << std::endl;
        #endif
      
        if (special_v->get_aux_is_set(0) && special_v->get_aux_is_set(1))
          set_data_by_comparison_result(special_v, EQUAL);
        else
		  // this is a new vertex inside the face, so we need to update its
		  // aux source information from face also (done in method)
          copy_all_data_to_vertex(face, special_v);
      } else
        CGAL_assertion(special_v->get_aux_is_set(0) && special_v->get_aux_is_set(1));
     }
    
    // assert all new faces got data set, if not, then maybe no curve cuts the face,
    // and should use regular resolve_minimal_face
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "check all face parts: " << result_face_parts.size() << std::endl;
    #endif
    typename std::list<Face_handle>::iterator new_face_it;
    for(new_face_it = result_face_parts.begin();
        new_face_it != result_face_parts.end(); ++new_face_it)
    {
      Face_handle new_face = *new_face_it;
      if (!new_face->is_decision_set())
      {
        Comparison_result res = resolve_minimal_face(new_face);
        copy_data_by_comparison_result(face, new_face, res);
      }

      // check face boundary for "data from face" features
      #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
        copy_data_to_face_boundary(new_face);
      #endif
    }

    minimal_face_timer.stop();
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "finish resolve face " << std::endl;
    #endif

  }    

  // get an edge with 2 surfaces defined over it, and split it to get the shape
  // of the envelope of these surfaces over the edge


  void resolve(Halfedge_handle edge, Minimization_diagram_2& result)
  {
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "in resolve edge" << std::endl;
    #endif
    Xy_monotone_surface_3 surf1 = get_aux_surface(edge, 0);
    Xy_monotone_surface_3 surf2 = get_aux_surface(edge, 1);
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "resolve edge: compared surfaces are:" << surf1 << std::endl << surf2 << std::endl;
    #endif

    // find the projected intersections
    std::list<Object> inter_objs;
    edge_intersection_timer.start();
    get_projected_intersections(surf1, surf2, std::back_inserter(inter_objs));
    edge_intersection_timer.stop();

    if (inter_objs.size() == 0)
    {
      resolve_minimal_edge(edge, edge);
      #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
        copy_data_to_edge_endpoints(edge);
      #endif
      return;
    }

    edge_2d_inter_timer.start();
    const X_monotone_curve_2& original_cv = edge->curve();
    const Point_2& original_left = traits->construct_min_vertex_2_object()(original_cv);
    const Point_2& original_right = traits->construct_max_vertex_2_object()(original_cv);

    // we want to work on the halfedge going from left to right
    if (original_left != edge->source()->point())
      edge = edge->twin();
      
    Vertex_handle original_src = edge->source();
    Vertex_handle original_trg = edge->target();
    
    // we should have a list of points where we should split the edge's curve
    // we then will sort the list, and split the curve

    // we should pay a special attension for overlaps, since we can get special
    // edges

    // we associate with every point 2 flags:
    // 1. is the point a left endpoint of an overlapping segment
    // 2. is the point a right endpoint of an overlapping segment
    typedef std::vector<Point_2_with_info>      Points_vec;
    Points_vec                                  split_points;

    Point_2 point;
    Intersection_curve icurve;
    Object cur_obj;

    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "resolve edge: need to deal with " << inter_objs.size()
                << " intersection objects" << std::endl;
    #endif

    std::list<Object>::iterator inter_objs_it = inter_objs.begin();
    for(; inter_objs_it != inter_objs.end(); ++inter_objs_it)
    {
      cur_obj = *inter_objs_it; 
      CGAL_assertion(!cur_obj.is_empty());
      if (assign(point, cur_obj))
      {
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "found intersection point: " << point << std::endl;
        #endif

        // if the point is on the curve, should add it the the split points
        // list, otherwise, it is irrelevant and should be ignored
        if (is_point_on_curve(point, original_cv, original_left, original_right))
          split_points.push_back(Point_2_with_info(point, false, false));
      }
      else if (assign(icurve, cur_obj))
      {
        Curve_2 curve = icurve.first;
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "found intersection curve: " << curve << std::endl;
        #endif

        // find the intersection points and overlapping segments with the
        // original curve and insert them to the list of split points

        // first, get x_monotone parts
        std::list<Object>                     x_objects;
        std::list<Object>::const_iterator     obj_it;
        const X_monotone_curve_2             *x_curve;
        const Point_2                        *iso_p;

        traits->make_x_monotone_2_object()(curve,
                                           std::back_inserter(x_objects));

        for (obj_it = x_objects.begin(); obj_it != x_objects.end(); ++obj_it)
        {
          x_curve = object_cast<X_monotone_curve_2> (&(*obj_it));
          if (x_curve != NULL)

          {
            // intersect the x-monotone curve with the edge's curve
            typedef std::pair<Point_2, unsigned int> Intersect_point_2;
            std::list<Object> intersections_list;
            const Intersect_point_2  *ip;
            const X_monotone_curve_2 *icv;
            
            traits->intersect_2_object()(*x_curve, original_cv,
                                         std::back_inserter(intersections_list));

            std::list<Object>::iterator inter_it = intersections_list.begin();
            for(; inter_it != intersections_list.end(); ++inter_it)
            {
              ip = object_cast<Intersect_point_2> (&(*inter_it));
              if (ip != NULL)
              {
                split_points.push_back(Point_2_with_info(ip->first, false, false));
              }
              else
              {
                icv = object_cast<X_monotone_curve_2> (&(*inter_it));
                CGAL_assertion (icv != NULL);

                split_points.push_back(Point_2_with_info(
                                           traits->construct_min_vertex_2_object()(*icv),
                                           true, false));
                split_points.push_back(Point_2_with_info(
                                           traits->construct_max_vertex_2_object()(*icv),
                                           false, true));
              }
            }            
          }
          else
          {
            iso_p = object_cast<Point_2> (&(*obj_it));
            CGAL_assertion (iso_p != NULL);
            // if the point is on the curve, should add it the the split points
            // list, otherwise, it is irrelevant and should be ignored
            if (is_point_on_curve(*iso_p, original_cv, original_left, original_right))
              split_points.push_back(Point_2_with_info(*iso_p, false, false));
          }
        }        
      }
      else
        CGAL_assertion_msg(false, "wrong projected intersection type");
    }
    edge_2d_inter_timer.stop();
    
    // if there aren't any split points, we can finish
    if (split_points.size() == 0)
    {
      resolve_minimal_edge(edge, edge);
      #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
        copy_data_to_edge_endpoints(edge);
      #endif
      return;
    }

    edge_split_timer.start();
    
    // sort the split points from left to right
    // and split the original edge in these points
    Points_compare comp(*traits);
    std::sort(split_points.begin(), split_points.end(), comp);

    // find if vertical surfaces are involved here, since if not, we can save
    // calls to traits methods (we know that over projected intersection the
    // surfaces are equal on the envelope, which is not neccessarily true if
    // vertical surfaces are involved)
    bool are_verticals_involved = false;
//    if (traits->is_vertical_3_object()(surf1) ||
//        traits->is_vertical_3_object()(surf2))
//      are_verticals_involved = true;    
    
    // check if source is a special vertex (i.e. also a projected intersection)
    // by checking the first point in the list
    bool source_is_special = false;
    CGAL_assertion(split_points.size() >= 1);
    if (split_points[0].first == original_src->point())
      source_is_special = true;
    
    // check if target is a special vertex, by checking the last point in the list
    bool target_is_special = false;
    if (split_points[split_points.size()-1].first == original_trg->point())
      target_is_special = true;

    // if overlaps > 0 it will indicate that we are inside an overlapping segment
    // meaning, we have a special edge
    int overlaps = 0;    

    // remember the envelope decision over the first & last parts, to
    // be able to copy it to the original endpoints
    // TODO: the initial value is only needed to shut up the compiler
    // TODO: is this realy needed, or we can use the decision made on "edge"
    // (is "edge" always the first part? )
    Comparison_result first_part_res = EQUAL;
    
    // cur_part is the part of the original edge that might be split
    Halfedge_handle cur_part = edge;

    for(unsigned int i=0; i<split_points.size(); ++i)
    {
      Point_2_with_info cur_p = split_points[i];
      // if we get to the target vertex, we end the loop, since no more splits

      // are needed
      if (cur_p.first == original_trg->point())
        break;
        
      Vertex_handle cur_src_vertex = cur_part->source();

      // check that the current split point is not already a vertex
      if (cur_p.first != cur_src_vertex->point())
      {
        // split the edge in this point
        X_monotone_curve_2 a,b;
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "before edge_split, curve=" << cur_part->curve() << std::endl <<
                       " point= " << cur_p.first << std::endl;
        #endif
        traits->split_2_object()(cur_part->curve(), cur_p.first, a, b);
        // todo: can we use the internal split?
        Halfedge_handle split_he = result.split_edge(cur_part, a, b);
        // split always returns the halfedge with source = cur_part.source
        CGAL_assertion(split_he->source() == cur_src_vertex);

        // the new vertex is split_he->target(), we set envelope data on it
        if (!are_verticals_involved)
          copy_all_data_to_vertex(edge, split_he->target());
        else
          //resolve(split_he->target());
          deal_with_new_vertex(edge, split_he->target());

        // identify the part of the split edge that we are finished with
        // (this is the one with cur_src_vertex),
        // and the part that might be split again
        Halfedge_handle finished_part = split_he;
        cur_part = split_he->next();

        // set the envelope data over the finished part
        // if the finished part is a special edge, and no verticals are involved
        // we can set both aux data on it. otherwise we should use the traits
        // compare method.
        Comparison_result finished_part_res;
        if (overlaps > 0 && !are_verticals_involved)
          finished_part_res = EQUAL;
        else
          finished_part_res = resolve_minimal_edge(edge, finished_part);

        finished_part->set_decision(finished_part_res);
        finished_part->twin()->set_decision(finished_part_res);

        if (finished_part == edge)
          first_part_res = finished_part_res;
      }

      // check the overlaps indications
      if (cur_p.second == true)
        ++overlaps; // we start a new overlapping segment at this point
      if (cur_p.third == true)
        --overlaps; // we end an overlapping segment at this point
              
    }

    // set envelope data on the last part (cur_part)
    // if the last part is a special edge, and no verticals are involved
    // we can set both aux data on it. otherwise we should use the traits
    // compare method.
    Comparison_result cur_part_res;
    if (overlaps > 0 && !are_verticals_involved)
      cur_part_res = EQUAL;
    else
      cur_part_res = resolve_minimal_edge(edge, cur_part);

    cur_part->set_decision(cur_part_res);
    cur_part->twin()->set_decision(cur_part_res);

    if (cur_part == edge)
      first_part_res = cur_part_res;
      
    // if the original source and target have same aux data as the edge
    // we can set envelope data over them also
    // if they are special vertices, we set both aux data. otherwise we copy
    // from the incident edge part.


    // the incident edge part to source should be edge (the first part)
    CGAL_assertion(original_src == edge->source());
    if (!original_src->is_decision_set() &&
        !are_verticals_involved &&
        can_copy_decision_from_edge_to_vertex(edge->twin()))
    {
      if (source_is_special)
        set_data_by_comparison_result(original_src, EQUAL);
      #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
        else
          set_data_by_comparison_result(original_src, first_part_res);
      #endif

    }
    // the incident edge part to target should be cur_part (the last part)
    CGAL_assertion(original_trg == cur_part->target());
    if (!original_trg->is_decision_set() &&
        !are_verticals_involved &&
        can_copy_decision_from_edge_to_vertex(cur_part))
    {
      if (target_is_special)
        set_data_by_comparison_result(original_trg, EQUAL);
      #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
        else
          set_data_by_comparison_result(original_trg, cur_part_res);
      #endif
    }
    edge_split_timer.stop();    

  }
  
  // get a vertex with 2 surfaces defined over it and decide the envelope data
  // on it between them
  void resolve(Vertex_handle vertex)
  {
    // it is enough to compare only one surface from each group (because they
    // all overlap over the vertex), but set all the group
    Xy_monotone_surface_3 surf1 = get_aux_surface(vertex, 0);
    Xy_monotone_surface_3 surf2 = get_aux_surface(vertex, 1);
    Point_2 point_2 = vertex->point();
    Comparison_result cur_res = compare_distance_to_envelope(point_2,surf1,surf2);
    vertex->set_decision(cur_res);
  }

  /*! Access the traits object (const version). */
  const Traits* get_traits () const
  {
    return (traits);
  }

  /*! Access the traits object (non-const version). */
  Traits* get_traits ()
  {
    return (traits);
  }

  void reset()
  {
    reset_statistics();
  }

  void reset_statistics()
  {
    if (intersection_timer.is_running())
      intersection_timer.stop();
    if (copied_arr_timer.is_running())
      copied_arr_timer.stop();
    if (zone_timer.is_running())
      zone_timer.stop();
    if (minimal_face_timer.is_running())
      minimal_face_timer.stop();

    if (edge_intersection_timer.is_running())
      edge_intersection_timer.stop();
    if (edge_2d_inter_timer.is_running())
      edge_2d_inter_timer.stop();
    if (edge_split_timer.is_running())
      edge_split_timer.stop();

    intersection_timer.reset();
    copied_arr_timer.reset();
    zone_timer.reset();
    minimal_face_timer.reset();

    edge_intersection_timer.reset();
    edge_2d_inter_timer.reset();
    edge_split_timer.reset();
  }
  
  void print_times()
  {
    #ifdef CGAL_BENCH_ENVELOPE_DAC
      std::cout << "resolve face times: " << std::endl;
      std::cout << "intersections: " << intersection_timer.time() << " seconds" << std::endl;
      std::cout << "copied_arr: " << copied_arr_timer.time() << " seconds" << std::endl;
      std::cout << "zone calculation: " << zone_timer.time() << " seconds" << std::endl;
      std::cout << "envelope data: " << minimal_face_timer.time() << " seconds" << std::endl;
      std::cout << std::endl;
      std::cout << "resolve edge times: " << std::endl;
      std::cout << "intersections: " << edge_intersection_timer.time() << " seconds" << std::endl;
      std::cout << "2d intersections: " << edge_2d_inter_timer.time() << " seconds" << std::endl;
      std::cout << "split & compare: " << edge_split_timer.time() << " seconds" << std::endl;

      std::cout << std::endl
          << "determine a feature's shape took: "
          << intersection_timer.time() + copied_arr_timer.time() + zone_timer.time()
          << "seconds " << std::endl
          << "labelling took: " << minimal_face_timer.time() <<std::endl;

    #endif    
  }

protected:
  
  // compute Comparison_result of surfaces over the face, assuming they get 
  // the same answer for all points in face
  // if we get a halfedge, it is assumed to be on the outer boundary of the 
  // face, and its curve is assumed to be a projected intersection curve, 
  // and we compare the surfaces to the left/right of it
  // otherwise we compare the surfaces over an (arbitrary) edge of the face,
  // assuming this is the correct answer for the face since the surfaces are 
  // continous
  // In either case, we try to copy decision from an incident face, is possible
  // before asking the geometric question
  Comparison_result resolve_minimal_face(Face_handle face, 
                                         Halfedge_handle* he = NULL)
  {
    CGAL_precondition(he == NULL || (*he)->face() == face);
    CGAL_assertion(!face->is_unbounded());
    Comparison_result res;

    bool success = false;
    #ifdef CGAL_ENVELOPE_SAVE_COMPARISONS
      success = can_copy_decision_from_boundary_edge(face, res);
    #endif
    
    if (success)
      return res;
      
    Xy_monotone_surface_3 surf1 = get_aux_surface(face, 0);
    Xy_monotone_surface_3 surf2 = get_aux_surface(face, 1);

    if (he == NULL)
    {
      // compare the surfaces over arbitrary edge
      Ccb_halfedge_circulator hec = face->outer_ccb();
      X_monotone_curve_2 cv = hec->curve();
      res = compare_distance_to_envelope(cv,surf1,surf2);
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in resolve_minimal_face, with no halfedge, got " 
                  << res << std::endl;
      #endif
	
      // check that result is equal on all edges
      CGAL_assertion_code(	
        Ccb_halfedge_circulator hec_begin = hec;    
        ++hec;
        while (hec != hec_begin)
        {
          Comparison_result tmp = 
                        compare_distance_to_envelope(hec->curve(),surf1,surf2);
      )
      CGAL_assertion_msg(tmp == res, 
                         "compare over curve returns non-consistent results");
      CGAL_assertion_code(
          ++hec;

        }
      )
    }
    else
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in resolve_minimal_face, with halfedge " << std::endl;
      #endif
      // compare the surfaces over the halfedge's curve
      X_monotone_curve_2 cv = (*he)->curve();

      CGAL_assertion_code(
        bool same_dir = (traits->construct_min_vertex_2_object()(cv) ==
                         (*he)->source()->point());
        bool left_to_right = ((*he)->direction() == SMALLER);
      );
      CGAL_assertion(same_dir == left_to_right);

      // a face is always to the left of its halfedge
      if ((*he)->direction() == SMALLER)
        res = traits->compare_distance_to_envelope_above_3_object()
                                                   (cv,surf1,surf2);
      else
        res = traits->compare_distance_to_envelope_below_3_object()
                                                   (cv,surf1,surf2);
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "resolve_minimal_face check " 

                  << (same_dir ? "left " : "right ") 
                  << "of curve " << cv << std::endl << "got " << res 
                  << std::endl;
      #endif
    }
    return res;
  }

  // use the Intersection type (Transversal/Tangent) and return the appropriate
  // comparison result of the other side of the intersection curve, 
  // if the first side has result "res"
  Comparison_result resolve_by_intersection_type(Comparison_result res,
                                                 Intersection_type itype)
  {
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "resolve_by_intersection_type called" << std::endl;
    #endif
    
    if (itype == TRANSVERSAL)
    {
      if (res == LARGER)
        return SMALLER;
      else if (res == SMALLER)
        return LARGER;
      else
        return res;
    }
    else
    {
      CGAL_assertion(itype == TANGENT);
      return res;
    }

  }
  
  // find intersections between 2 xy-monotone surfaces
  // use caching for repeating questions of same pair of surfaces
  template <class OutputIterator>
  OutputIterator get_projected_intersections(Xy_monotone_surface_3& s1,
                                             Xy_monotone_surface_3& s2,
                                             OutputIterator o)
  {
    return traits->construct_projected_intersections_2_object()(s1, s2, o);
  }

  // Geometry can be a Point_2 or a X_monotone_curve_2
  template <class Geometry>
  Comparison_result compare_distance_to_envelope(Geometry& g,
                                                 Xy_monotone_surface_3& s1,
                                                 Xy_monotone_surface_3& s2)
  {
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "compare distance on " << g << std::endl;
    #endif
    return traits->compare_distance_to_envelope_3_object()(g, s1, s2);   
  }

  // helper method to get the surfaces we need to work on
  template <class FeatureHandle>
  Xy_monotone_surface_3 get_aux_surface(FeatureHandle fh, unsigned int id)
  {
	  Object o = fh->get_aux_source(id);
    CGAL_assertion(!o.is_empty());
    Xy_monotone_surface_3 data;
    
    Halfedge_handle h;
    Vertex_handle v;
  	Face_handle f;

    // aux source of a face must be a face!
    // aux source of a halfedge can be face or halfedge
    // aux source of a vertex can be face, halfedge or vertex
    // this is why we start with a check for a face, then halfedge
    // and last vertex
  	if (assign(f, o))
  	  data = f->get_data();
  	else if (assign(h, o))
  	  data = h->get_data();
  	else
  	{
      CGAL_assertion_code(bool b =)
      assign(v, o);
      CGAL_assertion(b);
  	  data = v->get_data();
  	}
    return data;
  }
                                  
  bool can_copy_decision_from_face_to_edge(Halfedge_handle h)
  {
    // can copy decision from face to its incident edge if the aux
    // envelopes are continous over the face and edge
    return (h->get_has_equal_aux_data_in_face(0) &&
            h->get_has_equal_aux_data_in_face(1));
  }

  bool can_copy_decision_from_edge_to_vertex(Halfedge_handle h)
  {
    // can copy decision from face to its incident edge if the aux
    // envelopes are continous over the face and edge
    return (h->get_has_equal_aux_data_in_target(0) &&
            h->get_has_equal_aux_data_in_target(1));
  }


/*  template <class OutputIterator>
  OutputIterator find_ccb_unique_edges(Ccb_halfedge_circulator hec,
                                       OutputIterator o)
  {
    // when having "antena" in the ccb, edge might appear twice
    // (with its 2 halfedges) on the boundary
    // we keep here those halfedges that its twin is also on this face's boundary
    // as a stack
    std::deque<Halfedge_handle> antena;
    Ccb_halfedge_circulator hec_begin = hec;
    do {
      Halfedge_handle hh = hec;
      if (hh->twin()->face() == hh->face() &&
          antena.size() > 0 &&
          antena.back() == hh->twin())
      {
        antena.pop_back();
      }
      else
      {
        if (hh->twin()->face() == hh->face())
           antena.push_back(hh);
        *o++ = hh;
      }
      hec++;
    } while(hec != hec_begin);
    CGAL_assertion(antena.size() == 0);
    return o;
  }
*/

//  void print_ccb(Ccb_halfedge_circulator hec)
//  {
//    std::cout << "print ccb: " << std::endl;
//    Ccb_halfedge_circulator hec_begin = hec;
//    do {
//      Halfedge_handle h = hec;
//      std::cout << h->source()->point() << " --> " << h->target()->point() << std::endl;
//      hec++;
//    } while(hec != hec_begin);
//  }

  // check the aux data on the edges & vertices of the boundary of the face,
  // and if it equals the aux data on the face, copy it, to save calculations for
  // these features later
  // also consider isolated vertices
  // "res" is the decision made on the face
  void copy_data_to_face_boundary(Face_handle face)
  {
    Ccb_halfedge_circulator ccb = face->outer_ccb();
    copy_data_to_face_boundary(face, ccb);

    Hole_iterator inner_iter = face->holes_begin();
    for (; inner_iter != face->holes_end(); ++inner_iter)
    {
      ccb = (*inner_iter);
      copy_data_to_face_boundary(face, ccb);
    }

    Isolated_vertex_iterator iso_iter = face->isolated_vertices_begin();
    for (; iso_iter != face->isolated_vertices_end(); ++iso_iter)
    {
      Vertex_handle vh = iso_iter;
      if (!vh->is_decision_set() && has_equal_aux_data_with_face(vh))
        // can copy the data from the face, since we already took care of
        // the vertices of projected intersections
        vh->set_decision(face->get_decision());
    }
  }

  void copy_data_to_face_boundary(Face_handle face,
                                  Ccb_halfedge_circulator hec)
  {
    Ccb_halfedge_circulator hec_begin = hec;
    do {
      Halfedge_handle hh = hec;
      CGAL_assertion(face == hh->face());
      // if it is a vertical decomposition edge, copy data from face
      if (!hh->is_decision_set() && hh->get_is_fake())
      {
        hh->set_decision(face->get_decision());
        hh->twin()->set_decision(face->get_decision());
      }
      else if (!hh->is_decision_set() && can_copy_decision_from_face_to_edge(hh))
      {
        // copy the decision from face to the edge
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "copy from face to edge " << hh->curve() << std::endl;
        #endif
        hh->set_decision(face->get_decision());
        hh->twin()->set_decision(hh->get_decision());
      }
      // TODO: is this correct? shouldn't we split the edge first?
      // I think it is correct, because there is no intersection (of
      // the edges aux sources) over the edge, as if there was such
      // intersection, there would also be intersection between the surfaces
      // over the face, and we know now that there isn't.
      
      // if the first map is continous, but the second isn't (i.e. when we move
      // from the face to the edge, the envelope goes closer), then if the
      // second map wins on the face, it wins on the edge also
      else if (!hh->is_decision_set() &&
               face->get_decision() == SECOND &&
               hh->get_has_equal_aux_data_in_face(0) &&
               !hh->get_has_equal_aux_data_in_face(1))
      {
        hh->set_decision(SECOND);
        hh->twin()->set_decision(SECOND);

      }
      // if the second map is continous, but the first isn't, then if the
      // first map wins on the face, it wins on the edge also
      else if (!hh->is_decision_set() &&
               face->get_decision() == FIRST &&
               !hh->get_has_equal_aux_data_in_face(0) &&
               hh->get_has_equal_aux_data_in_face(1))
      {
        hh->set_decision(FIRST);
        hh->twin()->set_decision(FIRST);
      }

      // conclude to the vertices
      // we check both endpoints, since it can be possible that we cannot
      // conclude from one edge, bt can conclude from the other
      conclude_decision_to_vertex(hh->source(), hh->twin(), face, false);
      conclude_decision_to_vertex(hh->target(), hh, face, true);
                      
      hec++;
    } while(hec != hec_begin); 
  }

  // try to conclude the decision from the halfedge or the face to the vertex
  // the method assumes that the vertex is an endpoint of the edge represented
  // by "hh", which lies on the boundary of "fh"
  // the last bool indicates whether to check if possible to conclude from
  // face to vertex. it is only possible when hh->face == fh
  void conclude_decision_to_vertex(Vertex_handle vh, Halfedge_handle hh,
                                   Face_handle fh, bool try_vertex_face)
  {
    if (vh->is_decision_set())
      return;


    // first, we try to copy decision from edge, then from face
    if (hh->is_decision_set() &&
        can_copy_decision_from_edge_to_vertex(hh))
    {
      vh->set_decision(hh->get_decision());
    }
    // if the first map is continous, but the second isn't (i.e. when we move
    // from the edge to the vertex, the envelope goes closer), then if the
    // second map wins on the edge, it wins on the vertex also
    else if (hh->get_decision() == SECOND &&
             hh->get_has_equal_aux_data_in_target(0) &&
             !hh->get_has_equal_aux_data_in_target(1))
    {
      vh->set_decision(SECOND);
    }
    // if the second map is continous, but the first isn't, then if the
    // first map wins on the edge, it wins on the vertex also
    else if (hh->get_decision() == FIRST &&
             !hh->get_has_equal_aux_data_in_target(0) &&
             hh->get_has_equal_aux_data_in_target(1))
    {
      vh->set_decision(FIRST);
    }
    // check if we can copy from the face
    // todo: what if has_equal has 3 possible values? (and projected intersection
    // vertices have unknown flags)
    else if (try_vertex_face)
	{
      CGAL_assertion(has_equal_aux_data_in_target_and_face(hh) == 
	                 has_equal_aux_data(vh, fh));
      if (has_equal_aux_data_in_target_and_face(hh))
	  {
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
  	      //std::cout << "check edge->vertex " << hh->curve() << " --> " << vh->point() << std::endl;
          std::cout << "copy from face to vertex " << vh->point() << std::endl;
        #endif

        // can copy the data from the face, since we already took care of
        // the vertices of projected intersections
        vh->set_decision(fh->get_decision());
	  }
	}
  }
  
  // todo: this is for checking
  template <class InputIterator>
  bool has_equal_data(const InputIterator & begin1,
                      const InputIterator & end1,
                      const InputIterator & begin2,
                      const InputIterator & end2)
  {
    // insert the input data objects into a set
    std::set<Xy_monotone_surface_3> first(begin1, end1);
    std::set<Xy_monotone_surface_3> second(begin2, end2);
    std::list<Xy_monotone_surface_3> intersection;
    std::set_intersection(first.begin(), first.end(),

                          second.begin(), second.end(),
                          std::back_inserter(intersection));

    return (intersection.size() > 0);
  }
  // todo: this is for checking
  template <class FeatureHandle>
  void get_aux_data_iterators(unsigned int id, FeatureHandle fh,
                              Envelope_data_iterator& begin,
                              Envelope_data_iterator& end)
  {
    Halfedge_handle h;
    Vertex_handle v;
  	Face_handle f;

    Object o = fh->get_aux_source(id);
    CGAL_assertion(!o.is_empty());

    if (assign(v, o))
    {
      begin = v->begin_data();
      end = v->end_data();
    }
    else if (assign(h, o))
    {
      begin = h->begin_data();
      end = h->end_data();
    }
    else
   	{
   	  CGAL_assertion(assign(f, o));
      assign(f, o);
      begin = f->begin_data();
      end = f->end_data();
   	}
  }

  // todo: this is for checking
  template <class FeatureHandle1, class FeatureHandle2>
  bool has_equal_aux_data(unsigned int id, FeatureHandle1 fh1, FeatureHandle2 fh2)
  {
    Envelope_data_iterator begin1, end1, begin2, end2;
    get_aux_data_iterators(id, fh1, begin1, end1);
    get_aux_data_iterators(id, fh2, begin2, end2);
	  bool has_eq = has_equal_data(begin1, end1, begin2, end2);
	  return has_eq;
  }

  // todo: this is for checking
  template <class FeatureHandle1, class FeatureHandle2>
  bool has_equal_aux_data(FeatureHandle1 fh1, FeatureHandle2 fh2)
  {
	  return (has_equal_aux_data(0, fh1, fh2) &&
		        has_equal_aux_data(1, fh1, fh2));
  }


//  // check if we can copy the decision made on an incident face to the current
//  // face (by using the edge between the faces)
//  // this is an old version for saving comparisons over a face, and should be replaced
//  // with can_copy_decision_from_boundary
//  bool can_copy_decision_from_incident_face(Face_handle face, Comparison_result& res)
//  {
//    bool result = false;
//    Ccb_halfedge_circulator hec = face->outer_ccb();
//    Ccb_halfedge_circulator hec_begin = hec;
//    do {
//      Halfedge_handle hh = hec;
//      // check the incident face
//      if (hh->twin()->face()->is_decision_set() &&
//          can_copy_decision_from_face_to_edge(hh->twin()) &&
//          can_copy_decision_from_face_to_edge(hh) &&
//          hh->is_decision_set() &&
//          hh->get_decision() != BOTH)
//      {
//        res = convert_decision_to_comparison_result(hh->get_decision());
//        result = true;
//      }
//
//      hec++;
//    } while(hec != hec_begin && !result);
//    return result;
//  }

  // check if we can copy the decision made on a boundary edge to the face
  // if so, res will contain this decision's comparison result
  bool can_copy_decision_from_boundary_edge(Face_handle face, Comparison_result& res)
  {
    bool result = false;
    // check outer boundary
    Ccb_halfedge_circulator hec = face->outer_ccb();
    Ccb_halfedge_circulator hec_begin = hec;
    do {
      Halfedge_handle hh = hec;
      if (can_copy_decision_from_face_to_edge(hh) &&

          hh->is_decision_set() &&
          hh->get_decision() != BOTH)
      {
        res = convert_decision_to_comparison_result(hh->get_decision());
        result = true;
      }
      // if the first map is continous, but the second isn't (i.e. when we move
      // from the edge to the face, the envelope goes farther), then if the
      // first map wins on the edge, it wins on the face also
      else if (hh->is_decision_set() &&
               hh->get_decision() == FIRST &&
               hh->get_has_equal_aux_data_in_face(0) &&
               !hh->get_has_equal_aux_data_in_face(1))
      {
        res = convert_decision_to_comparison_result(FIRST);
        result = true;
      } 
      // if the second map is continous, but the first isn't, then if the
      // second map wins on the edge, it wins on the face also
      else if (hh->is_decision_set() &&
               hh->get_decision() == SECOND &&
               !hh->get_has_equal_aux_data_in_face(0) &&
               hh->get_has_equal_aux_data_in_face(1))
      {
        res = convert_decision_to_comparison_result(SECOND);
        result = true;
      }           
      hec++;
    } while(hec != hec_begin && !result);
    if (result) return true;
    // check inner boundaries
    Hole_iterator hole_iter = face->holes_begin();
    for (; hole_iter != face->holes_end(); ++hole_iter)
    {
      hec = (*hole_iter);
      hec_begin = hec;

      do {
        Halfedge_handle hh = hec;
        if (can_copy_decision_from_face_to_edge(hh) &&
            hh->is_decision_set() &&
            hh->get_decision() != BOTH)
        {
          res = convert_decision_to_comparison_result(hh->get_decision());
          result = true;
        }
        // if the first map is continous, but the second isn't (i.e. when we move
        // from the edge to the face, the envelope goes farther), then if the
        // first map wins on the edge, it wins on the face also
        else if (hh->is_decision_set() &&
                 hh->get_decision() == FIRST &&
                 hh->get_has_equal_aux_data_in_face(0) &&
                 !hh->get_has_equal_aux_data_in_face(1))
        {
          res = convert_decision_to_comparison_result(FIRST);

          result = true;
        }
        // if the second map is continous, but the first isn't, then if the
        // second map wins on the edge, it wins on the face also
        else if (hh->is_decision_set() &&
                 hh->get_decision() == SECOND &&
                 !hh->get_has_equal_aux_data_in_face(0) &&
                 hh->get_has_equal_aux_data_in_face(1))
        {
          res = convert_decision_to_comparison_result(SECOND);
          result = true;
        }
  
        hec++;
      } while(hec != hec_begin && !result);
      if (result) return true;
    }

    return result;
  }

  Comparison_result convert_decision_to_comparison_result(CGAL::Dac_decision d)
  {
    if (d == FIRST)
      return SMALLER;
    else if (d == SECOND)
      return LARGER;
    else
      return EQUAL;
  }
  
  bool has_equal_aux_data_with_face(Vertex_handle v)
  {
    CGAL_assertion(v->is_isolated());
    return (v->get_has_equal_aux_data_in_face(0) &&
            v->get_has_equal_aux_data_in_face(1));
  }

  bool has_equal_aux_data_in_target_and_face(Halfedge_handle h)
  {
    return (h->get_has_equal_aux_data_in_target_and_face(0) &&
            h->get_has_equal_aux_data_in_target_and_face(1));
  }

  // check the aux data on the endpoint vertices of the edge
  // and if it equals the aux data on the edge, copy it, to save calculations for
  // these features later
  void copy_data_to_edge_endpoints(Halfedge_handle edge)
  {
    // take care for source
    if (!edge->source()->is_decision_set() &&
        can_copy_decision_from_edge_to_vertex(edge->twin()))
      // can copy the data from the edge, since we already took care of
      // the vertices of projected intersections
      edge->source()->set_decision(edge->get_decision());
    // if the first map is continous, but the second isn't (i.e. when we move
    // from the edge to the vertex, the envelope goes closer), then if the
    // second map wins on the edge, it wins on the vertex also
    else if (edge->get_decision() == SECOND &&
             edge->twin()->get_has_equal_aux_data_in_target(0) &&
             !edge->twin()->get_has_equal_aux_data_in_target(1))
    {
      edge->source()->set_decision(SECOND);
    }
    // if the second map is continous, but the first isn't, then if the
    // first map wins on the edge, it wins on the vertex also
    else if (edge->get_decision() == FIRST &&
             !edge->twin()->get_has_equal_aux_data_in_target(0) &&
             edge->twin()->get_has_equal_aux_data_in_target(1))
    {
      edge->source()->set_decision(FIRST);
    }

    // take care for target
    if (!edge->target()->is_decision_set() &&
        can_copy_decision_from_edge_to_vertex(edge))
      // can copy the data from the edge, since we already took care of
      // the vertices of projected intersections
      edge->target()->set_decision(edge->get_decision());
    // if the first map is continous, but the second isn't (i.e. when we move
    // from the edge to the vertex, the envelope goes closer), then if the
    // second map wins on the edge, it wins on the vertex also
    else if (edge->get_decision() == SECOND &&
             edge->get_has_equal_aux_data_in_target(0) &&
             !edge->get_has_equal_aux_data_in_target(1))
    {
      edge->target()->set_decision(SECOND);
    }
    // if the second map is continous, but the first isn't, then if the
    // first map wins on the edge, it wins on the vertex also
    else if (edge->get_decision() == FIRST &&
             !edge->get_has_equal_aux_data_in_target(0) &&
             edge->get_has_equal_aux_data_in_target(1))
    {
      edge->target()->set_decision(FIRST);
    }
  }

  
  // copy the halfedges of a ccb (in from) to the md "to" inside the face inside_face
  void copy_ccb(Ccb_halfedge_circulator hec, // the circulator to insert
                Minimization_diagram_2 &from,// the original arrangement
                Face_handle inside_face,     // the face in which we insert it
                Minimization_diagram_2 &to,  // the arrangement to which we insert

                Halfedges_map& map_copied_to_orig_halfedges,
                Vertices_map&  map_copied_to_orig_vertices,
                Halfedges_map& map_orig_to_copied_halfedges,
                Vertices_map&  map_orig_to_copied_vertices,
                bool is_outer_ccb, // do we copy an outer (or inner) ccb
                bool& fakes_exist) // this bool is assumed to be initialized already
  {
    Md_accessor to_accessor(to);
    // count the number of faces that are closed by this ccb
    // (it can be more than 1 in degenerate cases, when closed area hangs
    // on a boundary vertex)
    int n_faces_closed = 0;
    
    Ccb_halfedge_circulator hec_begin = hec;
    bool first_he = true;
    Halfedge_handle copied_prev_he;
    do {
      Halfedge_handle hh = hec;

      // update fakes_exist
      if (hh->get_is_fake()) fakes_exist = true;
      
      if (hh->twin()->face() == hh->face() &&
          map_orig_to_copied_halfedges.is_defined(hh))
      {
        // this can happen in the case of antennas, when we get to the same
        // antena halfedge from the other side
        copied_prev_he = map_orig_to_copied_halfedges[hh];
      }
      else
      {
        X_monotone_curve_2 current_cv = hh->curve();
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
	//std::cout << "original halfedge: " << std::endl;
	//std::cout << hh->source()->point() << " --> " << hh->target()->point()
	//          << std::endl;
        #endif
        if (first_he)
        {             
          first_he = false;
          // create the 2 vertices and connect them with the edge
          // copied_prev_he should be directed from copied_source to copied_target
          Vertex_handle copied_source = to_accessor.create_vertex(hh->source()->point());
          Vertex_handle copied_target = to_accessor.create_vertex(hh->target()->point());
          copied_prev_he = to_accessor.insert_in_face_interior_ex(current_cv,
                                                                  inside_face,
                                                                  copied_source,
                                                                  copied_target,
                                                                  hh->direction());
                                                                          
          map_copied_to_orig_halfedges[copied_prev_he] = hh;
          map_orig_to_copied_halfedges[hh] = copied_prev_he;
          map_copied_to_orig_halfedges[copied_prev_he->twin()] = hh->twin();
          map_orig_to_copied_halfedges[hh->twin()] = copied_prev_he->twin();

          map_copied_to_orig_vertices[copied_prev_he->source()] = hh->source();
          map_orig_to_copied_vertices[hh->source()] = copied_prev_he->source();
          map_copied_to_orig_vertices[copied_prev_he->target()] = hh->target();
          map_orig_to_copied_vertices[hh->target()] = copied_prev_he->target();
        }
        else
        {
          CGAL_assertion(map_copied_to_orig_halfedges[copied_prev_he]->target() == hh->source());

          // insert from vertex: prev_he->target()
          // should check if hh->target is already a vertex in the copied face
          // in which case we should use insert at vertices
          bool use_2_vertices = false;
          Vertex_handle copied_v2;
          if (map_orig_to_copied_vertices.is_defined(hh->target()))
          {
            use_2_vertices = true;
            copied_v2 = map_orig_to_copied_vertices[hh->target()];
          }

          Halfedge_handle copied_new_he;
          if (!use_2_vertices)
          {
            // create vertex for the new target, and insert the new edge
            Vertex_handle copied_target = to_accessor.create_vertex(hh->target()->point());
            copied_new_he = to_accessor.insert_from_vertex_ex(current_cv,
                                                              copied_prev_he,
                                                              copied_target,
                                                              hh->direction());

            
            // the target of copied_new_he is the new vertex, so it is directed
            // the same way as hh in "from"

            // update the vertices maps:
            map_copied_to_orig_vertices[copied_new_he->target()] = hh->target();
            map_orig_to_copied_vertices[hh->target()] = copied_new_he->target();
          }
          else
          {
            #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
              std::cout << "use 2 vertices: " << copied_prev_he->target()->point()
                        << " and " << copied_v2->point()
                        << std::endl;
            #endif
            ++n_faces_closed;
            
            // in order to insert the new edge we should determine the prev
            // halfedge of copied_v2 - this is done be going backwards on the
            // ccb (in the copied arrangement) until finding the first halfedge
            // with target copied_v2
            // (note that going on twin()->next() is problematic in case that
            // the inner boundary we traverse is made of several faces)
            Halfedge_handle copied_prev_v2 = copied_prev_he;
            while(copied_prev_v2->source() != copied_v2)
              copied_prev_v2 = copied_prev_v2->prev();
            copied_prev_v2 = copied_prev_v2->twin();

            CGAL_assertion_code(
              Halfedge_handle tmp =
                  to_accessor.locate_around_vertex(copied_v2, current_cv);
            );
            CGAL_assertion(tmp == copied_prev_v2);

            bool new_face;
            if (is_outer_ccb)
            {
              // if it is the first face created, and the last halfedge to
              // insert, this is a regular outer ccb, with no special
              // degeneracies (around the current vertices, at least)
              // so we can use the accessor method
              if (n_faces_closed == 1 &&
                  map_orig_to_copied_halfedges.is_defined(hh->next()))
              {
                copied_new_he = to_accessor.insert_at_vertices_ex

                                                     (current_cv,
                                                      copied_prev_he,
                                                      copied_prev_v2,
                                                      hh->direction(),
                                                      new_face);
                CGAL_assertion(new_face);
              }
              else
              {
                // TODO:can we use accessor method?
                copied_new_he = to.insert_at_vertices(current_cv, copied_prev_he, copied_prev_v2);
              }
              // in order to use the accessor version, we need to identify
              // the order in which to pass the halfedges
              // (we should be careful in cases where more than one face is
              // created by the outer ccb
            }
            else // copy inner boundary
            {
              // should always flip the side of the edge, because the face
              // that we close is never the copied face, even in strane
              // situations like this: (two faces thouch in vertex)
              //     ------         |\  /|
              //     | |\ |         | \/ |
              //     | | \|         | /\ |
              //     ---            |/  \|
              //
              //
              copied_new_he = to_accessor.insert_at_vertices_ex(current_cv,
                                                                copied_prev_v2,
                                                                copied_prev_he,
                                                                hh->twin()->direction(),
                                                                new_face);
              CGAL_assertion(new_face);
              copied_new_he = copied_new_he->twin();
            }

            CGAL_assertion(copied_new_he->target() == copied_v2);
          }
          // update the halfedges maps:
          map_copied_to_orig_halfedges[copied_new_he] = hh;
          map_copied_to_orig_halfedges[copied_new_he->twin()] = hh->twin();
          map_orig_to_copied_halfedges[hh] = copied_new_he;
          map_orig_to_copied_halfedges[hh->twin()] = copied_new_he->twin();

          // update the previous he
          copied_prev_he = copied_new_he;
        }
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
	//std::cout << "copied halfedge: " << std::endl;
	//std::cout << copied_prev_he->source()->point() << " --> " << copied_prev_he->target()->point()
	//          << std::endl;
        #endif
      }
      hec++;
    } while(hec != hec_begin);

  }

  // copy the halfedges of the boundary of face (in from) to the md "to"
  // return a handle to the copied face in "to"
  // precondition: "to" is empty
  Face_handle copy_face(Face_handle face, Minimization_diagram_2& from,
                        Minimization_diagram_2& to,
                        Halfedges_map& map_copied_to_orig_halfedges,
                        Vertices_map&  map_copied_to_orig_vertices,
                        bool& fakes_exist)
  {   
    CGAL_precondition(to.number_of_vertices() == 0);
    CGAL_precondition(!face->is_unbounded());
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "copying the original face - outer boundary" << std::endl;
    #endif

    fakes_exist = false;
    Vertices_map  map_orig_to_copied_vertices;
    Halfedges_map map_orig_to_copied_halfedges;
    
    Face_handle to_uf = to.unbounded_face();


    // first deal with outer boundary
    Ccb_halfedge_circulator hec = face->outer_ccb();
    copy_ccb(hec, from, to_uf, to,
             map_copied_to_orig_halfedges,
             map_copied_to_orig_vertices,
             map_orig_to_copied_halfedges,
             map_orig_to_copied_vertices,
             true,
             fakes_exist);
    CGAL_assertion(is_valid(to));

    // we need to find the copied face
    Hole_iterator to_uf_hi = to_uf->holes_begin();
    Ccb_halfedge_circulator to_uf_hec = (*to_uf_hi);
    CGAL_assertion(to_uf->number_of_holes() == 1);
    Halfedge_handle to_f_he = to_uf_hec->twin();


    // second, deal with inner boundaries
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "copying the original face - inner boundaries" << std::endl;
    #endif
    Hole_iterator hole_iter = face->holes_begin();
    for (; hole_iter != face->holes_end(); ++hole_iter)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "copying hole" << std::endl;
      #endif
      Ccb_halfedge_circulator he = (*hole_iter);
      copy_ccb(he, from, to_f_he->face(), to,

               map_copied_to_orig_halfedges,
               map_copied_to_orig_vertices,
               map_orig_to_copied_halfedges,
               map_orig_to_copied_vertices,
               false,
               fakes_exist);
      CGAL_assertion(is_valid(to));
    }

    // find the face in "to"
    Face_handle copied_face = to_f_he->face();

    // copy the isolated vertices inside the given face, if any
    // and save them in map_copied_to_orig_vertices
    #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
      std::cout << "copying the original face - isolated vertices" << std::endl;
    #endif
    Isolated_vertex_iterator isolated_iter = face->isolated_vertices_begin();
    for(; isolated_iter != face->isolated_vertices_end(); ++isolated_iter)
    {
      Vertex_handle copied_iso = to.insert_in_face_interior(isolated_iter->point(), copied_face);
      map_copied_to_orig_vertices[copied_iso] = isolated_iter;
      map_orig_to_copied_vertices[isolated_iter] = copied_iso;	  
    }    
    return copied_face;
  }
    
  // set envelope data in face "to" according to the comparison result of the
  // aux data of face "from"
  void copy_data_by_comparison_result(Face_handle from, Face_handle to, Comparison_result res)
  {
    CGAL_assertion_msg(from->get_aux_is_set(0), "aux_data(0) is not set");
    CGAL_assertion_msg(from->get_aux_is_set(1), "aux_data(1) is not set");
    to->set_aux_source(0, from->get_aux_source(0));
    to->set_aux_source(1, from->get_aux_source(1));
    to->set_decision(res);
  }

  // set envelope data in vertex "v" according to the comparison result of the
  // aux data of "v"
  void set_data_by_comparison_result(Vertex_handle v, Comparison_result res)
  {
    CGAL_assertion_msg(v->get_aux_is_set(0), "aux_data(0) is not set");
    CGAL_assertion_msg(v->get_aux_is_set(1), "aux_data(1) is not set");
    v->set_decision(res);
  }

  // set envelope data in halfedge "h" according to the comparison result of the
  // aux data of "h"
  void set_data_by_comparison_result(Halfedge_handle h, Comparison_result res)
  {
    CGAL_assertion_msg(h->get_aux_is_set(0), "aux_data(0) is not set");
    CGAL_assertion_msg(h->get_aux_is_set(1), "aux_data(1) is not set");
    h->set_decision(res);
  }

  // set envelope data in vertex "to" according to the union of both
  // aux data of the feature "from"
  // FeatureHabdle should be a Face_handle, Halfedge_handle or 
  // Vertex_handle
  template <class FeatureHabdle>
  void copy_all_data_to_vertex(FeatureHabdle from, Vertex_handle to)
  {
    CGAL_assertion_msg(from->get_aux_is_set(0), "aux_data(0) is not set");
    CGAL_assertion_msg(from->get_aux_is_set(1), "aux_data(1) is not set");
    CGAL_assertion_msg(!to->is_decision_set(), "data is set in new vertex");
    to->set_aux_source(0, from->get_aux_source(0));
    to->set_aux_source(1, from->get_aux_source(1));
    to->set_decision(EQUAL);
  }

  void deal_with_new_vertex(Halfedge_handle orig_he, Vertex_handle new_v)
  {
    Xy_monotone_surface_3 surf1 = get_aux_surface(orig_he, 0);
    Xy_monotone_surface_3 surf2 = get_aux_surface(orig_he, 1);

    Point_2 p = new_v->point();
    Comparison_result res = compare_distance_to_envelope(p, surf1, surf2);
    new_v->set_aux_source(0, orig_he->get_aux_source(0));
    new_v->set_aux_source(1, orig_he->get_aux_source(1));
    new_v->set_decision(res);
  }
    
  Comparison_result resolve_minimal_edge(Halfedge_handle orig_he, Halfedge_handle new_he)
  {
    // find and set the envelope data on the new edge
    Xy_monotone_surface_3 surf1 = get_aux_surface(orig_he, 0);
    Xy_monotone_surface_3 surf2 = get_aux_surface(orig_he, 1);
    Comparison_result res = compare_distance_to_envelope(new_he->curve(), surf1, surf2);

//    new_he->set_aux_source(0, orig_he->get_aux_source(0));
//    new_he->set_aux_source(1, orig_he->get_aux_source(1));

//    new_he->twin()->set_aux_source(0, orig_he->get_aux_source(0));
//    new_he->twin()->set_aux_source(1, orig_he->get_aux_source(1));

   	// the observer keeps this information when splitting an edge
   	CGAL_assertion(new_he->get_aux_is_set(0) && new_he->get_aux_is_set(1));
   	CGAL_assertion(new_he->twin()->get_aux_is_set(0) && new_he->twin()->get_aux_is_set(1));

    new_he->set_decision(res);
    new_he->twin()->set_decision(res);
    return res;
  }


  // check if the point is on the curve
  // left and right should be the left and right endpoints of the curve cv
  bool is_point_on_curve(const Point_2& p, const X_monotone_curve_2& cv,
                         const Point_2& left, const Point_2& right)
  {
    CGAL_precondition(traits->equal_2_object()
                        (left, traits->construct_min_vertex_2_object()(cv)));

    CGAL_precondition(traits->equal_2_object()
                        (right, traits->construct_max_vertex_2_object()(cv)));
                        
    // we should check if the point is in the x range of the curve,
    // and if so, if it lies on it
    if ((traits->compare_x_2_object()(p, left) != SMALLER) &&

        (traits->compare_x_2_object()(p, right) != LARGER) &&
        (traits->compare_y_at_x_2_object()(p, cv) == EQUAL))
      return true;
    return false;
  }
  
  // this observer is used in the process of resolving a face
  // this observer should copy the faces' indication when a face is split
  // so we can later identify all the faces that form the original given face
  // it also should remember the edges of the face, that are also projected intersections
  class Copied_face_observer : public Md_observer

  {
  public:
    typedef typename Minimization_diagram_2::Face_handle         Face_handle;

    typedef typename Minimization_diagram_2::Halfedge_handle     Halfedge_handle;

    typedef typename Minimization_diagram_2::X_monotone_curve_2  X_monotone_curve_2;

    Copied_face_observer(Halfedges_map  &map_h)
      : map_halfedges(map_h)
    {
    }
    virtual ~Copied_face_observer() {}

    void set_elements_collections(Halfedges_hash& boundary,
                                  Halfedges_hash& specialh,
                                  Halfedges_hash_w_type& newh,
                                  Faces_hash& parts,
                                  Vertices_hash& boundaryv,
                                  Vertices_hash& specialv,
								  Vertices_to_edges_map& v_to_h)
    {
      boundary_halfedges = &boundary;
      special_edges = &specialh;
      new_edges = &newh;
      face_parts = &parts;
      boundary_vertices = &boundaryv;
      special_vertices = &specialv;
	  vertices_to_halfedges = &v_to_h;
    }
  
    virtual void after_split_face(Face_handle org_f,
                                  Face_handle new_f, bool)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in Copied_face_observer after_split_face" << std::endl;
      #endif
      // keep track of the face parts
      if (face_parts->is_defined(org_f))
        (*face_parts)[new_f] = face_parts->default_value();
     }

    virtual void after_split_edge(Halfedge_handle org_he,
                                  Halfedge_handle new_he)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in Copied_face_observer after_split_edge" << std::endl;
      #endif

      // take care of special edges that were split
      if (special_edges->is_defined(org_he))

      {
        // if original edge was in the set, then now both split parts should
        // be in the set
        (*special_edges)[new_he] = special_edges->default_value();
        (*special_edges)[new_he->twin()] = special_edges->default_value();
      }

      // take care of new edges that were split
      if (new_edges->is_defined(org_he))
      {
        (*new_edges)[new_he] = (*new_edges)[org_he];
        (*new_edges)[new_he->twin()] = (*new_edges)[org_he];
      }

      // take care for boundary edges
      if (boundary_halfedges->is_defined(org_he))
      {
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "original boundary edge was split" << std::endl;
        #endif

        (*boundary_halfedges)[new_he] = boundary_halfedges->default_value();
        (*boundary_halfedges)[new_he->twin()] =
                                        boundary_halfedges->default_value();

        // the new created vertex is a special vertex since it lies on the boundary
        // of the face, and it is of a projected intersection
        // we are interested in it only if the split halfedge is "data from face"
        CGAL_assertion(map_halfedges.is_defined(org_he));
        CGAL_assertion(org_he->target() == new_he->source());

        if ((map_halfedges[org_he])->get_has_equal_aux_data_in_face(0) &&
            (map_halfedges[org_he])->get_has_equal_aux_data_in_face(1))
          (*special_vertices)[org_he->target()] =
                              special_vertices->default_value();


        // update the boundary vertices collection
        (*boundary_vertices)[org_he->target()] =
                             boundary_vertices->default_value();


    		// update the vertices to halfedges collection
    		Halfedge_handle correct_side_he;
    		if (face_parts->is_defined(org_he->face()))
          correct_side_he = org_he;
    		else
    		{
          CGAL_assertion(face_parts->is_defined(new_he->twin()->face()));
    		  // new_he->twin() is directed as org_he, so on the boundary pointing
    		  // inside the face, and has the new vertex as target
    		  CGAL_assertion(org_he->target() == new_he->twin()->target());
          correct_side_he = new_he->twin();
     		}
		    // set the new vertex
        (*vertices_to_halfedges)[org_he->target()] = correct_side_he;

		    // update the old vertices (only one needs update, unless it is antenna)
		    CGAL_assertion(vertices_to_halfedges->is_defined(correct_side_he->source()) &&
			                 vertices_to_halfedges->is_defined(correct_side_he->next()->target()));
    		(*vertices_to_halfedges)[correct_side_he->next()->target()] = correct_side_he->next();

    		if (correct_side_he == org_he && face_parts->is_defined(org_he->twin()->face()))
    		  (*vertices_to_halfedges)[org_he->source()] = org_he->twin();

      }
    }

  protected:
    Halfedges_hash *boundary_halfedges;
    Halfedges_hash *special_edges;
    Halfedges_hash_w_type *new_edges;
    Faces_hash     *face_parts;
    Vertices_hash  *boundary_vertices;
    Vertices_hash  *special_vertices;
	Vertices_to_edges_map *vertices_to_halfedges;

    Halfedges_map  &map_halfedges;
  };


  // this observer is used in the process of resolving a face
  // it listens to what happpens in the copied arrangement, and copies back
  // the actions to result arrangements very efficiently
  class Copy_observer : public Md_observer
  {
  public:
    typedef typename Minimization_diagram_2::Face_handle         Face_handle;
    typedef typename Minimization_diagram_2::Halfedge_handle     Halfedge_handle;
    typedef typename Minimization_diagram_2::Vertex_handle       Vertex_handle;
    typedef typename Minimization_diagram_2::Point_2             Point_2;
    typedef typename Minimization_diagram_2::X_monotone_curve_2  X_monotone_curve_2;
    typedef typename Minimization_diagram_2::Ccb_halfedge_circulator
                                                        Ccb_halfedge_circulator;

    Copy_observer(Minimization_diagram_2& small,
                  Minimization_diagram_2& big,
                  Halfedges_map& map_h,
                  Vertices_map&  map_v,
                  Faces_map&     map_f)
      : small_arr(small), big_arr(big),
        big_arr_accessor(big_arr),
        map_halfedges(map_h),
        map_vertices(map_v),
        map_faces(map_f)

    {
    }
    
    virtual ~Copy_observer() {}

    virtual void before_create_vertex (const Point_2& /* p */)
    {}
    virtual void after_create_vertex (Vertex_handle v)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3

        std::cout << "in Copy_observer after_create_vertex" << std::endl;
      #endif
      
      // should create a new vertex with v->point() inside
      Vertex_handle new_v = big_arr_accessor.create_vertex(v->point());
      // save a mapping between the 2 vertices
      map_vertices[v] = new_v;
      // add indication of a new vertex (that is not connected to anything,
      // and is also no isolated)
      new_vertices.push_back(v);
    }

    virtual void before_create_edge (const X_monotone_curve_2& /* c */,
  				                           Vertex_handle v1,
  				                           Vertex_handle v2)
    {
      // save state for after_create_edge event
      create_edge_v1 = v1;
      create_edge_v2 = v2;

      is_in_relocate = false;
    }

    virtual void after_create_edge (Halfedge_handle e)

    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in Copy_observer after_create_edge" << std::endl;
      #endif
      // a new edge e was created in small_arr, we should create a corresponing
      // edge in big_arr
      CGAL_assertion(map_vertices.is_defined(create_edge_v1));
      CGAL_assertion(map_vertices.is_defined(create_edge_v2));
      CGAL_assertion(new_vertices.size() <= 2);

      Vertex_handle big_v1 = map_vertices[create_edge_v1];
      Vertex_handle big_v2 = map_vertices[create_edge_v2];
      
      // should check if v1 and v2 are new or old
      // if we have 2 new vertices, they must be new.
      // if we have only one, we should check which is new
      bool v1_is_new = false, v2_is_new = false;
      if (new_vertices.size() == 1)
      {
        if (new_vertices.back() == create_edge_v1)
          v1_is_new = true;
        else
        {
          CGAL_assertion(new_vertices.back() == create_edge_v2);
          v2_is_new = true;
        }          
      }
      if (new_vertices.size() == 2)
      {
        v1_is_new = true;
        v2_is_new = true;
      }
      new_vertices.clear();

      // just to make sure we have the halfedge in the same direction as
      // we got in the before event
      CGAL_assertion(e->source() == create_edge_v1);
      Halfedge_handle he = ((e->source() == create_edge_v1) ? e : e->twin());

      // if an endpoint is not new, but is isolated, we should remove it from
      // its face's isolated vertices list, and treat it as new
      if (!v1_is_new && big_v1->is_isolated())
      {
        //Face_handle f = big_v1->face(); //big_arr.incident_face(big_v1);
        //big_arr_accessor.find_and_erase_isolated_vertex(f, big_v1);
        big_arr_accessor.remove_isolated_vertex_ex(big_v1);
        v1_is_new = true;
      }
      if (!v2_is_new && big_v2->is_isolated())
      {
        //Face_handle f = big_v2->face(); //big_arr.incident_face(big_v2);
        //big_arr_accessor.find_and_erase_isolated_vertex(f, big_v2);
        big_arr_accessor.remove_isolated_vertex_ex(big_v2);
        v2_is_new = true;
      }

      // now use the approppriate method to insert the new edge
      if (v1_is_new && v2_is_new)
      {
        // if both vertices are new - use the O(1) operation
        // _insert_in_face_interior (in the face mapped to by he->face())
        CGAL_assertion(map_faces.is_defined(he->face()));

        Face_handle big_face = map_faces[he->face()];
        Halfedge_handle new_he =
                 big_arr_accessor.insert_in_face_interior_ex(he->curve(),
                                                             big_face,
                                                             big_v1, big_v2,
                                                             he->direction());

        // update mapping of new edge
        // new_he is directed from big_v1 to big_v2, and he is directed from
        // create_edge_v1 to create_edge_v2, so he is mapped to new_he
        map_halfedges[he] = new_he;
        map_halfedges[he->twin()] = new_he->twin();
      }
      else if (!v1_is_new && !v2_is_new)
      {
        // if both vertices are old - use _insert_at_vertices
        // this is a linear action by the size of the faces involved
        // we can get relevant prev halfedges from he
        Halfedge_handle prev1 = he->prev();
        Halfedge_handle prev2 = he->twin()->prev();

        CGAL_assertion(map_halfedges.is_defined(prev1));
        CGAL_assertion(map_halfedges.is_defined(prev2));

        Halfedge_handle big_prev1 = map_halfedges[prev1];
        Halfedge_handle big_prev2 = map_halfedges[prev2];

        bool new_face;
        Halfedge_handle new_he =
                 big_arr_accessor.insert_at_vertices_ex(he->curve(),

                                                        big_prev1, big_prev2,
                                                        he->direction(),
                                                        new_face);
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "in copy_observer, use insert at vertices" << std::endl;
          std::cout << (!new_face ? "no " : "") <<  "new face created" << std::endl;
        #endif
        // new_he should be directed as he

        CGAL_assertion(map_vertices.is_defined(he->source()) &&
                       map_vertices[he->source()] == new_he->source() &&
                       map_vertices.is_defined(he->target()) &&
                       map_vertices[he->target()] == new_he->target());

        // update mapping of new edge
        map_halfedges[he] = new_he;
        map_halfedges[he->twin()] = new_he->twin();

        // make sure that the old face is mapped already
        CGAL_assertion(map_faces.is_defined(he->twin()->face()) &&
                       map_faces[he->twin()->face()] == new_he->twin()->face());

        // if a new face was created update its mapping too
        // the new face is the incident face of he
        if (new_face)
        {
          map_faces[he->face()] = new_he->face();
          // save state for move_hole/move_isolated_vertex events
          is_in_relocate = true;
        }


        // make sure the face is correctly mapped
        CGAL_assertion(map_faces.is_defined(he->face()) &&
                       map_faces[he->face()] == new_he->face());
      }
      else
      {
        // only one vertex is new - use the O(1) operation _insert_from_vertex
        // we can get the relevant prev halfedge from e
        Halfedge_handle prev = he->prev();
        CGAL_assertion(map_halfedges.is_defined(prev));
        Halfedge_handle big_prev = map_halfedges[prev];
        Halfedge_handle new_he;
        if (!v1_is_new)
        {
          new_he = big_arr_accessor.insert_from_vertex_ex(he->curve(),
                                                          big_prev, big_v2,
                                                          he->direction());
          // update mapping of new edge
          // new_he is directed from big_v1 to big_v2 as he
          map_halfedges[he] = new_he;
          map_halfedges[he->twin()] = new_he->twin();          
        }
        else
        {
          new_he = big_arr_accessor.insert_from_vertex_ex(he->curve(),
                                                          big_prev, big_v1,
                                                          he->direction());
          // update mapping of new edge
          // new_he is directed from big_v2 to big_v1 opposite of he
          map_halfedges[he] = new_he->twin();
          map_halfedges[he->twin()] = new_he;

        }
      }
    }

    virtual void before_split_edge (Halfedge_handle e,
                                    Vertex_handle v,
                                    const X_monotone_curve_2& /* c1 */,
                                    const X_monotone_curve_2& /* c2 */)
    {
      // save state info for using _split_edge in after event
      split_v = v;
      split_e = e;
    }
    virtual void after_split_edge (Halfedge_handle e1,
                                   Halfedge_handle e2)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in Copy_observer after_split_edge" << std::endl;
      #endif
      // find the corresponding split vertex in big_arr
      CGAL_assertion(map_vertices.is_defined(split_v));
      Vertex_handle big_v = map_vertices[split_v];

      // make sure it is the only new vertex right now
      CGAL_assertion(new_vertices.size() == 1 &&
                     new_vertices.back() == split_v);
      new_vertices.pop_back();

      // find the edge to split in big_arr
      CGAL_assertion(map_halfedges.is_defined(split_e));
      Halfedge_handle big_e = map_halfedges[split_e];

      // use the O(1) operation _split_edge      
      Halfedge_handle big_e1 =
               big_arr_accessor.split_edge_ex(big_e, big_v,
                                              e1->curve(), e2->curve());

      Halfedge_handle big_e2 = big_e1->next();
      
      // update mapping of new halfedges
      // big_e1 is directed at big_v, as e1 is directed at split_v -
      // these are supposed to be mapped
      CGAL_assertion(map_halfedges.is_defined(e1) &&
                     map_halfedges[e1] == big_e1);
      // should update the mapping of the second halfedge     
      map_halfedges[e2] = big_e2;
      map_halfedges[e2->twin()] = big_e2->twin();
    }

    virtual void before_add_isolated_vertex (Face_handle f,
  					   Vertex_handle /* v */)
    {
      saved_face = f;
    }
    virtual void after_add_isolated_vertex (Vertex_handle v)
    {
      // make sure it is the only new vertex right now
      CGAL_assertion(new_vertices.size() == 1 &&
                     new_vertices.back() == v);
      new_vertices.pop_back();


      CGAL_assertion(map_vertices.is_defined(v));
      CGAL_assertion(map_faces.is_defined(saved_face));
      
      // find features in big_arr
      Vertex_handle big_v = map_vertices[v];

      Face_handle   big_face = map_faces[saved_face];
      

      // can use O(1) operation _insert_isolated_vertex
      big_arr_accessor.insert_isolated_vertex(big_face, big_v);
    }

    virtual void before_move_hole (Face_handle from_f,
                                   Face_handle to_f,

                                   Ccb_halfedge_circulator h)
    {
      // should be used after insert_at_vertices which creates a new face
      CGAL_assertion(is_in_relocate);
      move_from = from_f;
      move_to = to_f;
    }
    virtual void after_move_hole (Ccb_halfedge_circulator h)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in Copy_observer after_move_hole" << std::endl;
      #endif
      CGAL_assertion(map_faces.is_defined(move_from));
      CGAL_assertion(map_faces.is_defined(move_to));
      CGAL_assertion(map_halfedges.is_defined(h));

      Face_handle big_from_f  = map_faces[move_from];
      Face_handle big_to_f = map_faces[move_to];
      Ccb_halfedge_circulator big_h = (map_halfedges[h])->ccb();

      Ccb_halfedge_circulator big_ccb = big_h;
      
      big_arr_accessor.move_hole(big_from_f, big_to_f, big_ccb);

    }

    virtual void before_move_isolated_vertex (Face_handle from_f,
  					      Face_handle to_f,
  					      Vertex_handle v)
    {
      // should be used after insert_at_vertices which creates a new face

      CGAL_assertion(is_in_relocate);
      move_from = from_f;
      move_to = to_f;
    }
    virtual void after_move_isolated_vertex (Vertex_handle v)
    {
      CGAL_assertion(map_faces.is_defined(move_from));
      CGAL_assertion(map_faces.is_defined(move_to));
      CGAL_assertion(map_vertices.is_defined(v));

      Face_handle big_from_f  = map_faces[move_from];
      Face_handle big_to_f = map_faces[move_to];
      Vertex_handle big_v = map_vertices[v];

      big_arr_accessor.move_isolated_vertex(big_from_f, big_to_f, big_v);
    }

  protected:
    Minimization_diagram_2& small_arr;
    Minimization_diagram_2& big_arr;
    Md_accessor             big_arr_accessor;

    // mappings between small_arr features to big_arr features
    Halfedges_map& map_halfedges;
    Vertices_map&  map_vertices;
    Faces_map&     map_faces;
    std::deque<Vertex_handle> new_vertices;
    
    // state for actions
    Vertex_handle create_edge_v1;
    Vertex_handle create_edge_v2;
    Vertex_handle split_v;
    Halfedge_handle split_e;
    Face_handle   saved_face;
    Face_handle   move_from;
    Face_handle   move_to;    
    bool is_in_relocate;
    
  };

  // A zone visitor for the Minimization Diagram which only inserts
  // parts of the curve which are inside a given face
  // it also remembers those parts which overlap the boundary of the original face
  class Copied_face_zone_visitor
  {
  public:
    typedef typename Minimization_diagram_2::Vertex_handle       Vertex_handle;
    typedef typename Minimization_diagram_2::Halfedge_handle     Halfedge_handle;
    typedef typename Minimization_diagram_2::Face_handle         Face_handle;


    typedef typename Minimization_diagram_2::Point_2             Point_2;
    typedef typename Minimization_diagram_2::X_monotone_curve_2  X_monotone_curve_2;

    typedef std::pair<Halfedge_handle, bool>                     Result;

    Copied_face_zone_visitor(Minimization_diagram_2& result,
                             Minimization_diagram_2& copied,
                             Face_handle orig_face,
                             Face_handle copied_face,
                             Halfedges_map  &map_h,

                             Vertices_map   &map_v,
                             Faces_map      &map_f,
                             Halfedges_list &se, // special edges
                             Halfedges_w_type_list &new_edges,
                             Faces_list     &face_parts,
                             Vertices_list  &sv, // special vertices
                             Self* p)
          : copied_arr(copied),
            result_arr(result),
            result_original_face(orig_face),
            map_halfedges(map_h),
            map_vertices(map_v),
            map_faces(map_f),
            result_special_edges(se),
            result_new_edges(new_edges),
            result_face_parts(face_parts),
            result_special_vertices(sv),
            md_copy_observer(copied, result, map_h, map_v, map_f),
            md_observer(map_h),
            parent(p)
    {
      // init maps
      copied_face_parts[copied_face] = copied_face_parts.default_value();

      Halfedge_iterator hi = copied_arr.halfedges_begin();
      for(; hi != copied_arr.halfedges_end(); ++hi)
      {
        copied_arr_boundary_halfedges[hi] =
                   copied_arr_boundary_halfedges.default_value();
        if (hi->face() == copied_face)
		  copied_vertices_to_halfedges[hi->target()] = hi;
	  }
                   
      Vertex_iterator vi = copied_arr.vertices_begin();
      for(; vi != copied_arr.vertices_end(); ++vi)
      {
        copied_arr_orig_vertices[vi] =
                   copied_arr_orig_vertices.default_value();

		if (vi->is_isolated())
		{
          CGAL_assertion(vi->face() == copied_face);
          copied_vertices_to_halfedges[vi] = Halfedge_handle(NULL);
		}
		else
		  CGAL_assertion(copied_vertices_to_halfedges.is_defined(vi));
      }

      // init observers
      md_copy_observer.attach(copied_arr);
      
      md_observer.set_elements_collections(copied_arr_boundary_halfedges,
                                           copied_arr_special_edges,
                                           copied_arr_new_edges,
                                           copied_face_parts,
                                           copied_arr_new_boundary_vertices,
                                           copied_arr_special_vertices,
										   copied_vertices_to_halfedges);
      md_observer.attach(copied_arr);
    }

    virtual ~Copied_face_zone_visitor() { }

    // the zone visitor functions

    /*! Initialize the visitor with an arrangement object. */
    void init (Minimization_diagram_2 *arr)
    {
      CGAL_assertion(&copied_arr == arr);
      insert_visitor.init(arr);
    }

    /*!
     * Handle the a subcurve located in the interior of a given face.
     * \param cv The subcurve.
     * \param face The face containing cv's interior.
     * \param left_v The vertex that corresponds to the left endpoint of cv
     *               (or an invalid handle if no such arrangement vertex exists).
     * \param left_he The halfedge that contains the left endpoint of cv
     *               (or an invalid handle if no such halfedge exists).
     * \param right_v The vertex that corresponds to the right endpoint of cv
     *               (or an invalid handle if no such arrangement vertex exists).
     * \param right_he The halfedge that contains the right endpoint of cv
     *                 (or an invalid handle if no such halfedge exists).
     * \return A handle to the halfedge obtained from the insertion of the
     *         subcurve into the arrangement.
     */
    Result found_subcurve (const X_monotone_curve_2& cv,
                           Face_handle face,
                           Vertex_handle left_v, Halfedge_handle left_he,
                           Vertex_handle right_v, Halfedge_handle right_he)
    {
      // insert the curve only if the face is ok
      if (is_face_ok(face))
      {
        Result base_result = insert_visitor.found_subcurve(cv, face,
                                                           left_v, left_he,
                                                           right_v, right_he);
        // update the collection of newly added edges
        Halfedge_handle new_he = base_result.first;
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "found a new edge " << new_he->curve() << std::endl;
          std::cout << "from " << new_he->source()->point() << std::endl;
        #endif
        copied_arr_new_edges[new_he] = itype;
        copied_arr_new_edges[new_he->twin()] = itype;
        
        // take care for special vertices. the split vertices are always special,
        // and this is taken care of in the after_split event.

        // here we should update the original vertices that consolidate with the
        // new subcurve
        if (copied_arr_orig_vertices.is_defined(new_he->source()))
          copied_arr_special_vertices[new_he->source()] =
              copied_arr_special_vertices.default_value();

        if (copied_arr_orig_vertices.is_defined(new_he->target()))
          copied_arr_special_vertices[new_he->target()] =
              copied_arr_special_vertices.default_value();

    		// we should set the halfedge-face, halfedge-target 
		    // and target-face aux flags on the new edge (of result)
    		Halfedge_handle result_new_he = map_halfedges[new_he];
    		// it is clear that the halfedge-face are all true
        result_new_he->set_is_equal_aux_data_in_face(0, true);
        result_new_he->set_is_equal_aux_data_in_face(1, true);

        result_new_he->twin()->set_is_equal_aux_data_in_face(0, true);
        result_new_he->twin()->set_is_equal_aux_data_in_face(1, true);
        result_new_he->set_has_equal_aux_data_in_face(0, true);
        result_new_he->set_has_equal_aux_data_in_face(1, true);
        result_new_he->twin()->set_has_equal_aux_data_in_face(0, true);
        result_new_he->twin()->set_has_equal_aux_data_in_face(1, true);
        // for the halfedge-target flags, if the vertex is a boundary vertex
    		// we should use its boundary halfedge as intermediary between the face
    		// and the vertex (or the vertex info if it was isolated)
    		// otherwise, we set flags to true since it is a new vertex inside the
    		// original face, and have same aux data as all face parts
    		if (is_boundary_vertex(new_he->target()))
    		{
          Vertex_handle cur_t = new_he->target();
          CGAL_assertion(copied_vertices_to_halfedges.is_defined(cur_t));
          Halfedge_handle copied_b_he = copied_vertices_to_halfedges[cur_t];
    		  if (copied_b_he == Halfedge_handle(NULL))
          {
            // this was an isolated vertex, which we touch
            // since we have in the new edge aux sources as in the face,
            // we can copy the vertex-face flags from the vertex
            result_new_he->set_is_equal_aux_data_in_target
    		           (0, cur_t->get_is_equal_aux_data_in_face(0));
            result_new_he->set_is_equal_aux_data_in_target
    		           (1, cur_t->get_is_equal_aux_data_in_face(1));
            result_new_he->set_has_equal_aux_data_in_target
    		           (0, cur_t->get_has_equal_aux_data_in_face(0));
            result_new_he->set_has_equal_aux_data_in_target
    		           (1, cur_t->get_has_equal_aux_data_in_face(1));
            result_new_he->set_has_equal_aux_data_in_target_and_face
    		           (0, cur_t->get_has_equal_aux_data_in_face(0));
            result_new_he->set_has_equal_aux_data_in_target_and_face
    		           (1, cur_t->get_has_equal_aux_data_in_face(1));
    		  }
    		  else
    		  {
            CGAL_assertion(copied_b_he->target() == cur_t);
     	      CGAL_assertion(is_boundary_edge(copied_b_he));
            Halfedge_handle b_he = map_halfedges[copied_b_he];

            #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
     	        std::cout << "b_he=" << b_he->source()->point() << " --> " << b_he->target()->point();
            #endif

            bool flag;
       			flag = (b_he->get_is_equal_aux_data_in_face(0) &&
       				      b_he->get_is_equal_aux_data_in_target(0));
       			result_new_he->set_is_equal_aux_data_in_target(0, flag);

       			flag = (b_he->get_is_equal_aux_data_in_face(1) &&
       				      b_he->get_is_equal_aux_data_in_target(1));
       			result_new_he->set_is_equal_aux_data_in_target(1, flag);

            flag = b_he->get_has_equal_aux_data_in_target_and_face(0);
      			CGAL_assertion(flag == parent->has_equal_aux_data(0, b_he->face(), b_he->target()));
      			result_new_he->set_has_equal_aux_data_in_target(0, flag);
            result_new_he->set_has_equal_aux_data_in_target_and_face(0, flag);

            flag = b_he->get_has_equal_aux_data_in_target_and_face(1);
      			CGAL_assertion(flag == parent->has_equal_aux_data(1, b_he->face(), b_he->target()));
       			result_new_he->set_has_equal_aux_data_in_target(1, flag);
            result_new_he->set_has_equal_aux_data_in_target_and_face(1, flag);

    		  }
    		}
    		else // not a boundary vertex
        {
          result_new_he->set_is_equal_aux_data_in_target(0, true);
          result_new_he->set_is_equal_aux_data_in_target(1, true);
		      // the face's data is not empty - so it is ok to set "true" here
          result_new_he->set_has_equal_aux_data_in_target(0, true);
          result_new_he->set_has_equal_aux_data_in_target(1, true);
          result_new_he->set_has_equal_aux_data_in_target_and_face(0, true);
          result_new_he->set_has_equal_aux_data_in_target_and_face(1, true);
    		}

    		if (is_boundary_vertex(new_he->source()))
    		{
          Vertex_handle cur_t = new_he->source();
          CGAL_assertion(copied_vertices_to_halfedges.is_defined(cur_t));
          Halfedge_handle copied_b_he = copied_vertices_to_halfedges[cur_t];
    		  if (copied_b_he == Halfedge_handle(NULL))
          {
            // this was an isolated vertex, which we touch
            // since we have in the new edge aux sources as in the face,
            // we can copy the vertex-face flags from the vertex
            result_new_he->twin()->set_is_equal_aux_data_in_target
    		           (0, cur_t->get_is_equal_aux_data_in_face(0));
            result_new_he->twin()->set_is_equal_aux_data_in_target
    		           (1, cur_t->get_is_equal_aux_data_in_face(1));
            result_new_he->twin()->set_has_equal_aux_data_in_target
    		           (0, cur_t->get_has_equal_aux_data_in_face(0));
            result_new_he->twin()->set_has_equal_aux_data_in_target
    		           (1, cur_t->get_has_equal_aux_data_in_face(1));
            result_new_he->twin()->set_has_equal_aux_data_in_target_and_face
    		           (0, cur_t->get_has_equal_aux_data_in_face(0));
            result_new_he->twin()->set_has_equal_aux_data_in_target_and_face
    		           (1, cur_t->get_has_equal_aux_data_in_face(1));
    		  }
    		  else
    		  {
            CGAL_assertion(copied_b_he->target() == cur_t);
    	      CGAL_assertion(is_boundary_edge(copied_b_he));
            Halfedge_handle b_he = map_halfedges[copied_b_he];

            #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
              std::cout << "b_he=" << b_he->source()->point() << " --> " << b_he->target()->point();
            #endif
            bool flag;
      			flag = (b_he->get_is_equal_aux_data_in_face(0) &&
      				      b_he->get_is_equal_aux_data_in_target(0));
      			result_new_he->twin()->set_is_equal_aux_data_in_target(0, flag);

      			flag = (b_he->get_is_equal_aux_data_in_face(1) &&
      				      b_he->get_is_equal_aux_data_in_target(1));
      			result_new_he->twin()->set_is_equal_aux_data_in_target(1, flag);

            flag = b_he->get_has_equal_aux_data_in_target_and_face(0);
      			CGAL_assertion(flag == parent->has_equal_aux_data(0, b_he->face(), b_he->target()));
      			result_new_he->twin()->set_has_equal_aux_data_in_target(0, flag);
            result_new_he->twin()->set_has_equal_aux_data_in_target_and_face(0, flag);

            flag = b_he->get_has_equal_aux_data_in_target_and_face(1);
      			CGAL_assertion(flag == parent->has_equal_aux_data(1, b_he->face(), b_he->target()));
       			result_new_he->twin()->set_has_equal_aux_data_in_target(1, flag);
            result_new_he->twin()->set_has_equal_aux_data_in_target_and_face(1, flag);
    		  }
    		}
    		else
        {
          result_new_he->twin()->set_is_equal_aux_data_in_target(0, true);
          result_new_he->twin()->set_is_equal_aux_data_in_target(1, true);
          result_new_he->twin()->set_has_equal_aux_data_in_target(0, true);
          result_new_he->twin()->set_has_equal_aux_data_in_target(1, true);
          result_new_he->twin()->set_has_equal_aux_data_in_target_and_face(0, true);
          result_new_he->twin()->set_has_equal_aux_data_in_target_and_face(1, true);
    		}

        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
    		  std::cout << "set halfedge-vertex flags:"
    			          << std::endl;

    		  std::cout << "is equal(0) = " << result_new_he->get_is_equal_aux_data_in_target(0)
    			          << " is_equal(1) = " << result_new_he->get_is_equal_aux_data_in_target(1)
    			          << " has_equal(0) = " << result_new_he->get_has_equal_aux_data_in_target(0)
    			          << " has_equal(1) = " << result_new_he->get_has_equal_aux_data_in_target(1)
    			          << std::endl;
    		  std::cout << "for twin: " << std::endl;
    		  std::cout << "is equal(0) = " << result_new_he->twin()->get_is_equal_aux_data_in_target(0)
    			          << " is_equal(1) = " << result_new_he->twin()->get_is_equal_aux_data_in_target(1)
    			          << " has_equal(0) = " << result_new_he->twin()->get_has_equal_aux_data_in_target(0)
    			          << " has_equal(1) = " << result_new_he->twin()->get_has_equal_aux_data_in_target(1)
    			          << std::endl;

        #endif
        return base_result;
      }
      else
      {
        // we don't insert the subcurve, but it might touch a vertex of the
        // face's boundary - we need to check it and identify special vertices
        if (left_v != Vertex_handle(NULL) &&
            copied_arr_orig_vertices.is_defined(left_v))
          copied_arr_special_vertices[left_v] =
              copied_arr_special_vertices.default_value();

        if (right_v != Vertex_handle(NULL) &&
            copied_arr_orig_vertices.is_defined(right_v))
          copied_arr_special_vertices[right_v] =
              copied_arr_special_vertices.default_value();
        
        Halfedge_handle invalid_hh;
        return Result (invalid_hh, false);
      }
    }

    /*!
     * Handle the a subcurve that overlaps a given edge.
     * \param cv The overlapping subcurve.
     * \param he The overlapped halfedge (directed from left to right).
     * \param left_v The vertex that corresponds to the left endpoint of cv
     *               (or an invalid handle if no such arrangement vertex exists).
     * \param right_v The vertex that corresponds to the right endpoint of cv
     *               (or an invalid handle if no such arrangement vertex exists).
     * \return A handle to the halfedge obtained from the insertion of the
     *         overlapping subcurve into the arrangement.
     */
    Result found_overlap (const X_monotone_curve_2& cv,
                          Halfedge_handle he,
                          Vertex_handle left_v, Vertex_handle right_v)
    {
      // check if the halfedge is the boundary of the original face
      // (here we assume that this indication is dealt with in an observer
      //  attached to the md, and implements split_edge)
      bool is_boundary = is_boundary_edge(he);

      // use insert_visitor to get the halfedge with the overlap
      Result base_res = insert_visitor.found_overlap(cv, he, left_v, right_v);

      Halfedge_handle overlap_he = base_res.first;
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "In copied face zone visitor: found an overlap"
                  << overlap_he->curve() << std::endl;
      #endif

      // take care for special vertices. the split vertices are always special,
      // and this is taken care of in the after_split event.
      // here we should update the original vertices that consolidate with the
      // new subcurve
        if (copied_arr_orig_vertices.is_defined(overlap_he->source()))
          copied_arr_special_vertices[overlap_he->source()] =
              copied_arr_special_vertices.default_value();

        if (copied_arr_orig_vertices.is_defined(overlap_he->target()))
          copied_arr_special_vertices[overlap_he->target()] =
              copied_arr_special_vertices.default_value();

      if (!is_boundary)
        return base_res;

      // if he is a boundary edge, it is a special edge
      if (is_boundary)
      {
        #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
          std::cout << "In copied face zone visitor: found a special edge" << std::endl;
        #endif
        copied_arr_special_edges[overlap_he] =
                                 copied_arr_special_edges.default_value();
        copied_arr_special_edges[overlap_he->twin()] =
                                 copied_arr_special_edges.default_value();
       }
      return base_res;
    }

    /*!                                                   

     * Handle point that lies inside a given face.
     * \param p The point.
     * \param face The face inside which the point lies.
     * \return A handle to the new vertex obtained from the insertion of the
     *         point into the face, or invalid handle if the point wasn't
     *         inserted to the arrangement.
     */
    Vertex_handle found_point_in_face(const Point_2& p, Face_handle face)
    {
      // p lies inside a face: Insert it as an isolated vertex it the interior of
      // this face.
      Vertex_handle vh_for_p;
      if (is_face_ok(face))
      {
        vh_for_p = copied_arr.insert_in_face_interior(p, face);

      	// now should set the is_equal and has_equal flags
      	CGAL_assertion(map_vertices.is_defined(vh_for_p));
      	Vertex_handle result_new_v = map_vertices[vh_for_p];
      	result_new_v->set_is_equal_aux_data_in_face(0, true);
      	result_new_v->set_is_equal_aux_data_in_face(1, true);
        result_new_v->set_has_equal_aux_data_in_face(0, true);
      	result_new_v->set_has_equal_aux_data_in_face(1, true);
      }
      return vh_for_p;
    }

    /*!

     * Handle point that lies on a given edge.
     * \param p The point.
     * \param he The edge on which the point lies.
     * \return A handle to the new vertex obtained from the insertion of the
     *         point into the edge, or invalid handle if the point wasn't
     *         inserted to the arrangement.
     */
    Vertex_handle found_point_on_edge(const Point_2& p, Halfedge_handle he)
    {
      // p lies in the interior of an edge: Split this edge to create a new
      // vertex associated with p.
      X_monotone_curve_2  sub_cv1, sub_cv2;
      Halfedge_handle     split_he;
      copied_arr.get_traits()->split_2_object() (he->curve(), p, sub_cv1, sub_cv2);
      split_he = copied_arr.split_edge (he, sub_cv1, sub_cv2);

      // if the edge is a boundary edge, then the new vertex is a special vertex
      // and this is taken care of in the after_split event

      // TODO: should we update some is_equal / has_equal flags? 
      // I think that no, because it is handled in the after_split event

      // The new vertex is the target of the returned halfedge.

      return split_he->target();
    }

    /*!
     * Handle point that lies on a given vertex.
     * \param p The point.
     * \param v The vertex on which the point lies.
     * \return A handle to the new vertex obtained from the modifying
     *         the existing vertex.
     */
    Vertex_handle found_point_on_vertex(const Point_2& p, Vertex_handle v)
    {
      // if the vertex is a boundary vertex, then it is a special vertex
      // if it was created by split of a boundary edge, then it is already
      // marked as special. we need to mark it as special if it is an original
      // vertex
      if (copied_arr_orig_vertices.is_defined(v))
        copied_arr_special_vertices[v] =
                                   copied_arr_special_vertices.default_value();

      return copied_arr.modify_vertex (v, p);
    }

    /*!
     * Update all the output collections using the internal data saved during
     * the previous inserts.
     * Should be called after all inserts have finished.
     */
    void finish()
    {
      // result_special_edges
      // result_new_edges
      Halfedge_iterator hi = copied_arr.halfedges_begin();
      for(; hi != copied_arr.halfedges_end(); ++hi, ++hi)
      {
        Halfedge_handle h = hi;
        CGAL_assertion(map_halfedges.is_defined(h) &&
                       map_halfedges.is_defined(h->twin()));


        // we need only one of the twin halfedges to represent the new edge
        if (copied_arr_new_edges.is_defined(h))
          result_new_edges.push_back(std::make_pair(map_halfedges[h],
                                                    copied_arr_new_edges[h]));

        if (copied_arr_special_edges.is_defined(h))
        {
          // we need the halfedge that its incident face is inside the original
          // face
          Face_handle f1 = h->face(), f2 = h->twin()->face();
          if (copied_face_parts.is_defined(f1))

            result_special_edges.push_back(map_halfedges[h]);
          else
          {
            CGAL_assertion(copied_face_parts.is_defined(f2));
            result_special_edges.push_back(map_halfedges[h->twin()]);
          }
        }

      }

      // result_face_parts
      Face_iterator fi = copied_arr.faces_begin();
      for(; fi != copied_arr.faces_end(); ++fi)
      {
        Face_handle f = fi;
        if (copied_face_parts.is_defined(f))
        {
          CGAL_assertion(map_faces.is_defined(f));
          result_face_parts.push_back(map_faces[f]);
        }
      }
      
      // result_special_vertices
      Vertex_iterator vi = copied_arr.vertices_begin();
      for(; vi != copied_arr.vertices_end(); ++vi)

      {
        Vertex_handle v = vi;
        CGAL_assertion(map_vertices.is_defined(v));
        Vertex_handle result_v = map_vertices[v];
        
        if (copied_arr_orig_vertices.is_defined(v))
        {
          // original vertex should be mapped to a boundary halfedge whose
          // target is the vertex
          CGAL_assertion(copied_vertices_to_halfedges.is_defined(v));
   		  Halfedge_handle inc_he = copied_vertices_to_halfedges[v];
   		  CGAL_assertion(copied_face_parts.is_defined(inc_he->face()));

   		  Halfedge_handle result_inc_he = map_halfedges[inc_he];
          CGAL_assertion(result_inc_he->target() == result_v);
   		  CGAL_assertion(map_faces[inc_he->face()] == result_inc_he->face());

          // original vertex is special if it appears in the special collection
          // and its aux data share equal surfaces with the faces aux data
          if (copied_arr_special_vertices.is_defined(v) &&
              ((result_v->is_isolated() && 
			    parent->has_equal_aux_data_with_face(result_v)) ||
               (!result_v->is_isolated() && 
			    parent->has_equal_aux_data_in_target_and_face(result_inc_he)))) 
          {
            CGAL_assertion(parent->has_equal_aux_data(result_v, result_original_face));
            result_special_vertices.push_back(result_v); 
          }  
        }
        else
        {
          if (!copied_arr_new_boundary_vertices.is_defined(v))
            // new vertex inside the face
            result_special_vertices.push_back(result_v);
          else if (copied_arr_special_vertices.is_defined(v))
            result_special_vertices.push_back(result_v);
        }
      }
    }

    void set_current_intersection_type(Intersection_type t)
    {
      itype = t;
    }
  protected:

    bool is_face_ok(Face_handle face)
    {
      // is this face a part of the original face?
      // check in the copied_face_parts map
      return (copied_face_parts.is_defined(face));
    }

    bool is_boundary_edge(Halfedge_handle he)
    {
      return (copied_arr_boundary_halfedges.is_defined(he));
    }

    bool is_original_boundary_vertex(Vertex_handle v)
    {
      return (copied_arr_orig_vertices.is_defined(v));
    }
    bool is_boundary_vertex(Vertex_handle v)
    {
      return (copied_arr_orig_vertices.is_defined(v) ||
		      copied_arr_new_boundary_vertices.is_defined(v));
    }

  protected:
    // this zone visitor knows how to insert the given subcurves into the
    // minimization diagram. we use it to insert the subcurves we want (which
    // are in the given original face)
    Md_insert_zone_visitor insert_visitor;

    Minimization_diagram_2 &copied_arr;
    Minimization_diagram_2 &result_arr;
    Face_handle            result_original_face;
    
    // mappings between features in the 2 arrangements
    Halfedges_map &map_halfedges;
    Vertices_map  &map_vertices;
    Faces_map     &map_faces;

    // output lists
    Halfedges_list &result_special_edges;
    Halfedges_w_type_list &result_new_edges;
    Faces_list     &result_face_parts;
    Vertices_list  &result_special_vertices;

    // helper collections (for copied_arr features)
    Halfedges_hash        copied_arr_boundary_halfedges;
    Vertices_hash         copied_arr_orig_vertices;
    Vertices_hash         copied_arr_new_boundary_vertices;
    Vertices_to_edges_map copied_vertices_to_halfedges;    

    Halfedges_hash        copied_arr_special_edges;
    Halfedges_hash_w_type copied_arr_new_edges;
    Faces_hash            copied_face_parts;
    Vertices_hash         copied_arr_special_vertices;

    // this observer will take care of the result arrangegment
    Copy_observer        md_copy_observer;

    // this observer will keep all our information in the helper collections
    // during the insert process
    // (the special features info, boundary info, new_edges)
    Copied_face_observer md_observer;
    
    // for using its methods
    Self* parent;

    // current type of interection curve that is inserted
    Intersection_type itype;
  };

  // this minimization diagram observer updates data in new faces created
  class New_faces_observer : public Md_observer

  {
  public:
    typedef typename Minimization_diagram_2::Face_handle Face_handle;

    New_faces_observer(Minimization_diagram_2& arr)
            : Md_observer(arr)
    {}
    virtual ~New_faces_observer() {}

    virtual void after_split_face(Face_handle org_f,
                                  Face_handle new_f,
                                  bool)
    {
      #ifdef CGAL_DEBUG_ENVELOPE_DEQ_3
        std::cout << "in New_faces_observer::after_split_face" << std::endl;
      #endif


      // update the new face's aux_data from original face
      if (org_f->get_aux_is_set(0))
        new_f->set_aux_source(0, org_f->get_aux_source(0));
      if (org_f->get_aux_is_set(1))
        new_f->set_aux_source(1, org_f->get_aux_source(1));
    }

  };

  Traits             *traits;
  bool                own_traits; // Should we eventually free the traits object.

  // measure times for resolve face
  mutable Timer intersection_timer;
  mutable Timer copied_arr_timer;
  mutable Timer zone_timer;
  mutable Timer minimal_face_timer;

  // measure times for resolve edge
  mutable Timer edge_intersection_timer;
  mutable Timer edge_2d_inter_timer;
  mutable Timer edge_split_timer;
};

CGAL_END_NAMESPACE

#endif