libigl_Martin/include/igl/cgal/SelfIntersectMesh.h

#ifndef IGL_SELFINTERSECTMESH_H
#define IGL_SELFINTERSECTMESH_H

#include "CGAL_includes.hpp"
#include "selfintersect.h"

#include <Eigen/Dense>
#include <list>
#include <map>
#include <vector>

// The easiest way to keep track of everything is to use a class

namespace igl
{
  // Kernel is a CGAL kernel like:
  //     CGAL::Exact_predicates_inexact_constructions_kernel
  // or 
  //     CGAL::Exact_predicates_exact_constructions_kernel

  template <typename Kernel>
  class SelfIntersectMesh
  {
    public:
      // 3D Primitives
      typedef CGAL::Point_3<Kernel>    Point_3;
      typedef CGAL::Segment_3<Kernel>  Segment_3; 
      typedef CGAL::Triangle_3<Kernel> Triangle_3; 
      typedef CGAL::Plane_3<Kernel>    Plane_3;
      typedef CGAL::Tetrahedron_3<Kernel> Tetrahedron_3; 
      typedef CGAL::Polyhedron_3<Kernel> Polyhedron_3; 
      typedef CGAL::Nef_polyhedron_3<Kernel> Nef_polyhedron_3; 
      // 2D Primitives
      typedef CGAL::Point_2<Kernel>    Point_2;
      typedef CGAL::Segment_2<Kernel>  Segment_2; 
      typedef CGAL::Triangle_2<Kernel> Triangle_2; 
      // 2D Constrained Delaunay Triangulation types
      typedef CGAL::Triangulation_vertex_base_2<Kernel>  TVB_2;
      typedef CGAL::Constrained_triangulation_face_base_2<Kernel> CTFB_2;
      typedef CGAL::Triangulation_data_structure_2<TVB_2,CTFB_2> TDS_2;
      typedef CGAL::Exact_intersections_tag Itag;
      typedef CGAL::Constrained_Delaunay_triangulation_2<Kernel,TDS_2,Itag> 
        CDT_2;
      typedef CGAL::Constrained_triangulation_plus_2<CDT_2> CDT_plus_2;
      // Axis-align boxes for all-pairs self-intersection detection
      typedef std::vector<Triangle_3> Triangles;
      typedef typename Triangles::iterator TrianglesIterator;
      typedef typename Triangles::const_iterator TrianglesConstIterator;
      typedef 
        CGAL::Box_intersection_d::Box_with_handle_d<double,3,TrianglesIterator> 
        Box;
      // Axis-aligned bounding box tree
      typedef CGAL::AABB_triangle_primitive<Kernel,TrianglesIterator> Primitive;
      typedef CGAL::AABB_traits<Kernel, Primitive> Traits;
      typedef CGAL::AABB_tree<Traits> Tree;
      typedef typename Tree::Object_and_primitive_id Object_and_primitive_id;
      typedef typename Tree::Primitive_id Primitive_id;
      // 3D Delaunay Triangulation
      typedef CGAL::Delaunay_triangulation_3<Kernel> Delaunay_triangulation_3;
      typedef typename Delaunay_triangulation_3::Finite_cells_iterator 
        Delaunay3CellIterator;
  
      // Input mesh
      const Eigen::MatrixXd & V;
      const Eigen::MatrixXi & F;
      // Number of self-intersecting triangle pairs
      int count;
      std::vector<std::list<CGAL::Object> > F_objects;
      Triangles T;
      std::list<int> lIF;
      std::vector<bool> offensive;
      std::vector<int> offending_index;
      std::vector<int> offending;
      // Make a short name for the edge map's key
      typedef std::pair<int,int> EMK;
      // Make a short name for the type stored at each edge, the edge map's
      // value
      typedef std::list<int> EMV;
      // Make a short name for the edge map
      typedef std::map<EMK,EMV> EdgeMap;
      EdgeMap edge2faces;
    public:
      SelfintersectParam params;
    public:
      // Constructs (VV,FF) a new mesh with self-intersections of (V,F)
      // subdivided
      inline SelfIntersectMesh(
        const Eigen::MatrixXd & V,
        const Eigen::MatrixXi & F,
        const SelfintersectParam & params,
        Eigen::MatrixXd & VV,
        Eigen::MatrixXi & FF,
        Eigen::MatrixXi & IF);
    private:
      // Helper function to mark a face as offensive
      //
      // Inputs:
      //   f  index of face in F
      inline void mark_offensive(const int f);
      // Helper function to count intersections between faces
      //
      // Input:
      //   fa  index of face A in F
      //   fb  index of face B in F
      inline void count_intersection(const int fa,const int fb);
      // Helper function for box_intersect. Intersect two triangles A and B,
      // append the intersection object (point,segment,triangle) to a running
      // list for A and B
      //
      // Inputs:
      //   A  triangle in 3D
      //   B  triangle in 3D
      //   fa  index of A in F (and F_objects)
      //   fb  index of A in F (and F_objects)
      // Returns true only if A intersects B
      //
      inline bool intersect(
          const Triangle_3 & A, 
          const Triangle_3 & B, 
          const int fa,
          const int fb);
      // Helper function for box_intersect. In the case where A and B have
      // already been identified to share a vertex, then we only want to add
      // possible segment intersections. Assumes truly duplicate triangles are
      // not given as input
      //
      // Inputs:
      //   A  triangle in 3D
      //   B  triangle in 3D
      //   fa  index of A in F (and F_objects)
      //   fb  index of B in F (and F_objects)
      //   va  index of shared vertex in A (and F_objects)
      //   vb  index of shared vertex in B (and F_objects)
      //// Returns object of intersection (should be Segment or point)
      //   Returns true if intersection (besides shared point)
      //
      inline bool single_shared_vertex(
          const Triangle_3 & A,
          const Triangle_3 & B,
          const int fa,
          const int fb,
          const int va,
          const int vb);
      // Helper handling one direction
      inline bool single_shared_vertex(
          const Triangle_3 & A,
          const Triangle_3 & B,
          const int fa,
          const int fb,
          const int va);
      // Helper function for box_intersect. In the case where A and B have
      // already been identified to share two vertices, then we only want to add
      // a possible coplanar (Triangle) intersection. Assumes truly degenerate
      // facets are not givine as input.
      inline bool double_shared_vertex(
          const Triangle_3 & A,
          const Triangle_3 & B,
          const int fa,
          const int fb);
  
    public:
      // Callback function called during box self intersections test. Means
      // boxes a and b intersect. This method then checks if the triangles in
      // each box intersect and if so, then processes the intersections
      //
      // Inputs:
      //   a  box containing a triangle
      //   b  box containing a triangle
      inline void box_intersect(const Box& a, const Box& b);
    private:
      // Compute 2D delaunay triangulation of a given 3d triangle and a list of
      // intersection objects (points,segments,triangles). CGAL uses an affine
      // projection rather than an isometric projection, so we're not
      // guaranteed that the 2D delaunay triangulation here will be a delaunay
      // triangulation in 3D.
      //
      // Inputs:
      //   A  triangle in 3D
      //   A_objects_3  updated list of intersection objects for A
      // Outputs:
      //   cdt  Contrained delaunay triangulation in projected 2D plane
      inline void projected_delaunay(
          const Triangle_3 & A,
          const std::list<CGAL::Object> & A_objects_3,
          CDT_plus_2 & cdt);
      // Getters:
    public:
      //const std::list<int>& get_lIF() const{ return lIF;}
      static inline void box_intersect(
        SelfIntersectMesh * SIM, 
        const SelfIntersectMesh::Box &a, 
        const SelfIntersectMesh::Box &b);
  };
}

// Implementation

#include "mesh_to_cgal_triangle_list.h"

#include <igl/REDRUM.h>
#include <igl/C_STR.h>

#include <boost/function.hpp>
#include <boost/bind.hpp>

#include <algorithm>
#include <exception>
#include <cassert>
#include <iostream>

// References:
// http://minregret.googlecode.com/svn/trunk/skyline/src/extern/CGAL-3.3.1/examples/Polyhedron/polyhedron_self_intersection.cpp
// http://www.cgal.org/Manual/3.9/examples/Boolean_set_operations_2/do_intersect.cpp

// Q: Should we be using CGAL::Polyhedron_3?
// A: No! Input is just a list of unoriented triangles. Polyhedron_3 requires
// a 2-manifold.
// A: But! It seems we could use CGAL::Triangulation_3. Though it won't be easy
// to take advantage of functions like insert_in_facet because we want to
// constrain segments. Hmmm. Actualy Triangulation_3 doesn't look right...

//static void box_intersect(SelfIntersectMesh * SIM,const Box & A, const Box & B)
//{
//  return SIM->box_intersect(A,B);
//}


// CGAL's box_self_intersection_d uses C-style function callbacks without
// userdata. This is a leapfrog method for calling a member function. It should
// be bound as if the prototype was:
//   static void box_intersect(const Box &a, const Box &b)
// using boost:
//  boost::function<void(const Box &a,const Box &b)> cb
//    = boost::bind(&::box_intersect, this, _1,_2);
//   
template <typename Kernel>
inline void igl::SelfIntersectMesh<Kernel>::box_intersect(
  igl::SelfIntersectMesh<Kernel> * SIM, 
  const typename igl::SelfIntersectMesh<Kernel>::Box &a, 
  const typename igl::SelfIntersectMesh<Kernel>::Box &b)
{
  SIM->box_intersect(a,b);
}

#define FIRST_HIT_EXCEPTION 10

template <typename Kernel>
inline igl::SelfIntersectMesh<Kernel>::SelfIntersectMesh(
  const Eigen::MatrixXd & V,
  const Eigen::MatrixXi & F,
  const SelfintersectParam & params,
  Eigen::MatrixXd & VV,
  Eigen::MatrixXi & FF,
  Eigen::MatrixXi & IF):
  V(V),
  F(F),
  count(0),
  F_objects(F.rows()),
  T(),
  lIF(),
  offensive(F.rows(),false),
  offending_index(F.rows(),-1),
  offending(),
  edge2faces(),
  params(params)
{
  using namespace std;
  using namespace Eigen;
  // Compute and process self intersections
  mesh_to_cgal_triangle_list(V,F,T);
  // http://www.cgal.org/Manual/latest/doc_html/cgal_manual/Box_intersection_d/Chapter_main.html#Section_63.5 
  // Create the corresponding vector of bounding boxes
  std::vector<Box> boxes;
  boxes.reserve(T.size());
  for ( 
    TrianglesIterator tit = T.begin(); 
    tit != T.end(); 
    ++tit)
  {
    boxes.push_back(Box(tit->bbox(), tit));
  }
  // Leapfrog callback
  boost::function<void(const Box &a,const Box &b)> cb
    = boost::bind(&box_intersect, this, _1,_2);
  // Run the self intersection algorithm with all defaults
  try{
    CGAL::box_self_intersection_d(boxes.begin(), boxes.end(),cb);
  }catch(int e)
  {
    // Rethrow if not FIRST_HIT_EXCEPTION
    if(e != FIRST_HIT_EXCEPTION)
    {
      throw e;
    }
    // Otherwise just fall through
  }

  // Convert lIF to Eigen matrix
  assert(lIF.size()%2 == 0);
  IF.resize(lIF.size()/2,2);
  {
    int i=0;
    for(
      typename list<int>::const_iterator ifit = lIF.begin();
      ifit!=lIF.end();
      )
    {
      IF(i,0) = (*ifit);
      ifit++; 
      IF(i,1) = (*ifit);
      ifit++;
      i++;
    }
  }

  if(params.detect_only)
  {
    return;
  }

  int NF_count = 0;
  // list of new faces, we'll fix F later
  vector<MatrixXi> NF(offending.size());
  // list of new vertices
  list<Point_3> NV;
  int NV_count = 0;
  vector<CDT_plus_2> cdt(offending.size());
  vector<Plane_3> P(offending.size());
  // Use map for *all* faces
  map<typename CDT_plus_2::Vertex_handle,int> v2i;
  // Loop over offending triangles
  for(int o = 0;o<(int)offending.size();o++)
  {
    // index in F
    const int f = offending[o];
    projected_delaunay(T[f],F_objects[f],cdt[o]);
    // Q: Is this also delaunay in 3D?
    // A: No, because the projection is affine and delaunay is not affine
    // invariant.
    // Q: Then, can't we first get the 2D delaunay triangulation, then lift it
    // to 3D and flip any offending edges?
    // Plane of projection (also used by projected_delaunay)
    P[o] = Plane_3(T[f].vertex(0),T[f].vertex(1),T[f].vertex(2));
    // Build index map
    {
      int i=0;
      for(
        typename CDT_plus_2::Finite_vertices_iterator vit = cdt[o].finite_vertices_begin();
        vit != cdt[o].finite_vertices_end();
        ++vit)
      {
        if(i<3)
        {
          //cout<<T[f].vertex(i)<<
          //  (T[f].vertex(i) == P[o].to_3d(vit->point())?" == ":" != ")<<
          //  P[o].to_3d(vit->point())<<endl;
#ifndef NDEBUG
          // I want to be sure that the original corners really show up as the
          // original corners of the CDT. I.e. I don't trust CGAL to maintain the
          // order
          assert(T[f].vertex(i) == P[o].to_3d(vit->point()));
#endif
          // For first three, use original index in F
          v2i[vit] = F(f,i);
        }else
        {
          const Point_3 vit_point_3 = P[o].to_3d(vit->point());
          // First look up each edge's neighbors to see if exact point has
          // already been added (This makes everything a bit quadratic)
          bool found = false;
          for(int e = 0; e<3 && !found;e++)
          {
            // Index of F's eth edge in V
            int i = F(f,(e+1)%3);
            int j = F(f,(e+2)%3);
            // Be sure that i<j
            if(i>j)
            {
              swap(i,j);
            }
            assert(edge2faces.count(EMK(i,j))==1);
            // loop over neighbors
            for(
              list<int>::const_iterator nit = edge2faces[EMK(i,j)].begin();
              nit != edge2faces[EMK(i,j)].end() && !found;
              nit++)
            {
              // don't consider self
              if(*nit == f)
              {
                continue;
              }
              // index of neighbor in offending (to find its cdt)
              int no = offending_index[*nit];
              // Loop over vertices of that neighbor's cdt (might not have been
              // processed yet, but then it's OK because it'll just be empty)
              for(
                  typename CDT_plus_2::Finite_vertices_iterator uit = cdt[no].finite_vertices_begin();
                  uit != cdt[no].finite_vertices_end() && !found;
                  ++uit)
              {
                if(vit_point_3 == P[no].to_3d(uit->point()))
                {
                  assert(v2i.count(uit) == 1);
                  v2i[vit] = v2i[uit];
                  found = true;
                }
              }
            }
          }
          if(!found)
          {
            v2i[vit] = V.rows()+NV_count;
            NV.push_back(vit_point_3);
            NV_count++;
          }
        }
        i++;
      }
    }
    {
      int i = 0;
      // Resize to fit new number of triangles
      NF[o].resize(cdt[o].number_of_faces(),3);
      NF_count+=NF[o].rows();
      // Append new faces to NF
      for(
        typename CDT_plus_2::Finite_faces_iterator fit = cdt[o].finite_faces_begin();
        fit != cdt[o].finite_faces_end();
        ++fit)
      {
        NF[o](i,0) = v2i[fit->vertex(0)];
        NF[o](i,1) = v2i[fit->vertex(1)];
        NF[o](i,2) = v2i[fit->vertex(2)];
        i++;
      }
    }
  }
  assert(NV_count == (int)NV.size());
  // Build output
#ifndef NDEBUG
  {
    int off_count = 0;
    for(int f = 0;f<F.rows();f++)
    {
      off_count+= (offensive[f]?1:0);
    }
    assert(off_count==(int)offending.size());
  }
#endif
  // Append faces
  FF.resize(F.rows()-offending.size()+NF_count,3);
  // First append non-offending original faces
  // There's an Eigen way to do this in one line but I forget
  int off = 0;
  for(int f = 0;f<F.rows();f++)
  {
    if(!offensive[f])
    {
      FF.row(off++) = F.row(f);
    }
  }
  assert(off == (int)(F.rows()-offending.size()));
  // Now append replacement faces for offending faces
  for(int o = 0;o<(int)offending.size();o++)
  {
    FF.block(off,0,NF[o].rows(),3) = NF[o];
    off += NF[o].rows();
  }
  // Append vertices
  VV.resize(V.rows()+NV_count,3);
  VV.block(0,0,V.rows(),3) = V;
  {
    int i = 0;
    for(
      typename list<Point_3>::const_iterator nvit = NV.begin();
      nvit != NV.end();
      nvit++)
    {
      for(int d = 0;d<3;d++)
      {
        const Point_3 & p = *nvit;
        VV(V.rows()+i,d) = CGAL::to_double(p[d]);
        // This distinction does not seem necessary:
//#ifdef INEXACT_CONSTRUCTION
//        VV(V.rows()+i,d) = CGAL::to_double(p[d]);
//#else
//        VV(V.rows()+i,d) = CGAL::to_double(p[d].exact());
//#endif
      }
      i++;
    }
  }

  // Q: Does this give the same result as TETGEN?
  // A: For the cow and beast, yes.

  // Q: Is tetgen faster than this CGAL implementation?
  // A: Well, yes. But Tetgen is only solving the detection (predicates)
  // problem. This is also appending the intersection objects (construction).
  // But maybe tetgen is still faster for the detection part. For example, this
  // CGAL implementation on the beast takes 98 seconds but tetgen detection
  // takes 14 seconds

}


template <typename Kernel>
inline void igl::SelfIntersectMesh<Kernel>::mark_offensive(const int f)
{
  using namespace std;
  lIF.push_back(f);
  if(!offensive[f])
  {
    offensive[f]=true;
    offending_index[f]=offending.size();
    offending.push_back(f);
    // Add to edge map
    for(int e = 0; e<3;e++)
    {
      // Index of F's eth edge in V
      int i = F(f,(e+1)%3);
      int j = F(f,(e+2)%3);
      // Be sure that i<j
      if(i>j)
      {
        swap(i,j);
      }
      // Create new list if there is no entry
      if(edge2faces.count(EMK(i,j))==0)
      {
        edge2faces[EMK(i,j)] = list<int>();
      }
      // append to list
      edge2faces[EMK(i,j)].push_back(f);
    }
  }
}

template <typename Kernel>
inline void igl::SelfIntersectMesh<Kernel>::count_intersection(
  const int fa,
  const int fb)
{
  mark_offensive(fa);
  mark_offensive(fb);
  this->count++;
  // We found the first intersection
  if(params.first_only && this->count >= 1)
  {
    throw FIRST_HIT_EXCEPTION;
  }
}

template <typename Kernel>
inline bool igl::SelfIntersectMesh<Kernel>::intersect(
  const Triangle_3 & A, 
  const Triangle_3 & B, 
  const int fa,
  const int fb)
{
  // Determine whether there is an intersection
  if(!CGAL::do_intersect(A,B))
  {
    return false;
  }
  if(!params.detect_only)
  {
    // Construct intersection
    CGAL::Object result = CGAL::intersection(A,B);
    F_objects[fa].push_back(result);
    F_objects[fb].push_back(result);
  }
  count_intersection(fa,fb);
  return true;
}

template <typename Kernel>
inline bool igl::SelfIntersectMesh<Kernel>::single_shared_vertex(
  const Triangle_3 & A,
  const Triangle_3 & B,
  const int fa,
  const int fb,
  const int va,
  const int vb)
{
  ////using namespace std;
  //CGAL::Object result = CGAL::intersection(A,B);
  //if(CGAL::object_cast<Segment_3 >(&result))
  //{
  //  // Append to each triangle's running list
  //  F_objects[fa].push_back(result);
  //  F_objects[fb].push_back(result);
  //  count_intersection(fa,fb);
  //}else
  //{
  //  // Then intersection must be at point
  //  // And point must be at shared vertex
  //  assert(CGAL::object_cast<Point_3>(&result));
  //}
  if(single_shared_vertex(A,B,fa,fb,va))
  {
    return true;
  }
  return single_shared_vertex(B,A,fb,fa,vb);
}

template <typename Kernel>
inline bool igl::SelfIntersectMesh<Kernel>::single_shared_vertex(
  const Triangle_3 & A,
  const Triangle_3 & B,
  const int fa,
  const int fb,
  const int va)
{
  // This was not a good idea. It will not handle coplanar triangles well.
  using namespace std;
  Segment_3 sa(
    A.vertex((va+1)%3),
    A.vertex((va+2)%3));

  if(CGAL::do_intersect(sa,B))
  {
    CGAL::Object result = CGAL::intersection(sa,B);
    if(const Point_3 * p = CGAL::object_cast<Point_3 >(&result))
    {
      if(!params.detect_only)
      {
        // Single intersection --> segment from shared point to intersection
        CGAL::Object seg = CGAL::make_object(Segment_3(
          A.vertex(va),
          *p));
        F_objects[fa].push_back(seg);
        F_objects[fb].push_back(seg);
      }
      count_intersection(fa,fb);
      return true;
    }else if(CGAL::object_cast<Segment_3 >(&result))
    {
      //cerr<<REDRUM("Coplanar at: "<<fa<<" & "<<fb<<" (single shared).")<<endl;
      // Must be coplanar
      if(params.detect_only)
      {
        count_intersection(fa,fb);
      }else
      {
        // WRONG:
        //// Segment intersection --> triangle from shared point to intersection
        //CGAL::Object tri = CGAL::make_object(Triangle_3(
        //  A.vertex(va),
        //  s->vertex(0),
        //  s->vertex(1)));
        //F_objects[fa].push_back(tri);
        //F_objects[fb].push_back(tri);
        //count_intersection(fa,fb);
        // Need to do full test. Intersection could be a general poly.
        bool test = intersect(A,B,fa,fb);
        ((void)test);
        assert(test);
      }
      return true;
    }else
    {
      cerr<<REDRUM("Segment ∩ triangle neither point nor segment?")<<endl;
      assert(false);
    }
  }

  return false;
}


template <typename Kernel>
inline bool igl::SelfIntersectMesh<Kernel>::double_shared_vertex(
  const Triangle_3 & A,
  const Triangle_3 & B,
  const int fa,
  const int fb)
{
  using namespace std;
  // Cheaper way to do this than calling do_intersect?
  if(
    // Can only have an intersection if co-planar
    (A.supporting_plane() == B.supporting_plane() ||
    A.supporting_plane() == B.supporting_plane().opposite()) &&
    CGAL::do_intersect(A,B))
  {
    // Construct intersection
    try
    {
      CGAL::Object result = CGAL::intersection(A,B);
      if(result)
      {
        if(CGAL::object_cast<Segment_3 >(&result))
        {
          // not coplanar
          return false;
        } else if(CGAL::object_cast<Point_3 >(&result))
        {
          // this "shouldn't" happen but does for inexact
          return false;
        } else
        {
          if(!params.detect_only)
          {
            // Triangle object
            F_objects[fa].push_back(result);
            F_objects[fb].push_back(result);
          }
          count_intersection(fa,fb);
          //cerr<<REDRUM("Coplanar at: "<<fa<<" & "<<fb<<" (double shared).")<<endl;
          return true;
        }
      }else
      {
        // CGAL::intersection is disagreeing with do_intersect
        return false;
      }
    }catch(...)
    {
      // This catches some cgal assertion:
      //     CGAL error: assertion violation!
      //     Expression : is_finite(d)
      //     File       : /opt/local/include/CGAL/GMP/Gmpq_type.h
      //     Line       : 132
      //     Explanation: 
      // But only if NDEBUG is not defined, otherwise there's an uncaught
      // "Floating point exception: 8" SIGFPE
      return false;
    }
  }
  // Shouldn't get here either
  assert(false);
  return false;
}

template <typename Kernel>
inline void igl::SelfIntersectMesh<Kernel>::box_intersect(
  const Box& a, 
  const Box& b)
{
  using namespace std;
  // index in F and T
  int fa = a.handle()-T.begin();
  int fb = b.handle()-T.begin();
  const Triangle_3 & A = *a.handle();
  const Triangle_3 & B = *b.handle();
  // I'm not going to deal with degenerate triangles, though at some point we
  // should
  assert(!a.handle()->is_degenerate());
  assert(!b.handle()->is_degenerate());
  // Number of combinatorially shared vertices
  int comb_shared_vertices = 0;
  // Number of geometrically shared vertices (*not* including combinatorially
  // shared)
  int geo_shared_vertices = 0;
  // Keep track of shared vertex indices (we only handles single shared
  // vertices as a special case, so just need last/first/only ones)
  int va=-1,vb=-1;
  int ea,eb;
  for(ea=0;ea<3;ea++)
  {
    for(eb=0;eb<3;eb++)
    {
      if(F(fa,ea) == F(fb,eb))
      {
        comb_shared_vertices++;
        va = ea;
        vb = eb;
      }else if(A.vertex(ea) == B.vertex(eb))
      {
        geo_shared_vertices++;
        va = ea;
        vb = eb;
      }
    }
  }
  const int total_shared_vertices = comb_shared_vertices + geo_shared_vertices;
  if(comb_shared_vertices== 3)
  {
    // Combinatorially duplicate face, these should be removed by preprocessing
    cerr<<REDRUM("Facets "<<fa<<" and "<<fb<<" are combinatorial duplicates")<<endl;
    goto done;
  }
  if(total_shared_vertices== 3)
  {
    // Geometrically duplicate face, these should be removed by preprocessing
    cerr<<REDRUM("Facets "<<fa<<" and "<<fb<<" are geometrical duplicates")<<endl;
    goto done;
  }
  //// SPECIAL CASES ARE BROKEN FOR COPLANAR TRIANGLES
  //if(total_shared_vertices > 0)
  //{
  //  bool coplanar = 
  //    CGAL::coplanar(A.vertex(0),A.vertex(1),A.vertex(2),B.vertex(0)) &&
  //    CGAL::coplanar(A.vertex(0),A.vertex(1),A.vertex(2),B.vertex(1)) &&
  //    CGAL::coplanar(A.vertex(0),A.vertex(1),A.vertex(2),B.vertex(2));
  //  if(coplanar)
  //  {
  //    cerr<<MAGENTAGIN("Facets "<<fa<<" and "<<fb<<
  //      " are coplanar and share vertices")<<endl;
  //    goto full;
  //  }
  //}

  if(total_shared_vertices == 2)
  {
    // Q: What about coplanar?
    //
    // o    o
    // |\  /|
    // | \/ |
    // | /\ |
    // |/  \|
    // o----o
    double_shared_vertex(A,B,fa,fb);

    goto done;
  }
  assert(total_shared_vertices<=1);
  if(total_shared_vertices==1)
  {
    assert(va>=0 && va<3);
    assert(vb>=0 && vb<3);
//#ifndef NDEBUG
//    CGAL::Object result =
//#endif
    single_shared_vertex(A,B,fa,fb,va,vb);
//#ifndef NDEBUG
//    if(!CGAL::object_cast<Segment_3 >(&result))
//    {
//      const Point_3 * p = CGAL::object_cast<Point_3 >(&result);
//      assert(p);
//      for(int ea=0;ea<3;ea++)
//      {
//        for(int eb=0;eb<3;eb++)
//        {
//          if(F(fa,ea) == F(fb,eb))
//          {
//            assert(*p==A.vertex(ea));
//            assert(*p==B.vertex(eb));
//          }
//        }
//      }
//    }
//#endif
  }else
  {
//full:
    // No geometrically shared vertices, do general intersect
    intersect(*a.handle(),*b.handle(),fa,fb);
  }
done:
  return;
}

// Compute 2D delaunay triangulation of a given 3d triangle and a list of
// intersection objects (points,segments,triangles). CGAL uses an affine
// projection rather than an isometric projection, so we're not guaranteed
// that the 2D delaunay triangulation here will be a delaunay triangulation
// in 3D.
//
// Inputs:
//   A  triangle in 3D
//   A_objects_3  updated list of intersection objects for A
// Outputs:
//   cdt  Contrained delaunay triangulation in projected 2D plane
template <typename Kernel>
inline void igl::SelfIntersectMesh<Kernel>::projected_delaunay(
  const Triangle_3 & A,
  const std::list<CGAL::Object> & A_objects_3,
  CDT_plus_2 & cdt)
{
  using namespace std;
  // http://www.cgal.org/Manual/3.2/doc_html/cgal_manual/Triangulation_2/Chapter_main.html#Section_2D_Triangulations_Constrained_Plus
  // Plane of triangle A
  Plane_3 P(A.vertex(0),A.vertex(1),A.vertex(2));
  // Insert triangle into vertices
  typename CDT_plus_2::Vertex_handle corners[3];
  for(int i = 0;i<3;i++)
  {
    corners[i] = cdt.insert(P.to_2d(A.vertex(i)));
  }
  // Insert triangle edges as constraints
  for(int i = 0;i<3;i++)
  {
    cdt.insert_constraint( corners[(i+1)%3], corners[(i+2)%3]);
  }
  // Insert constraints for intersection objects
  for(
    typename list<CGAL::Object>::const_iterator lit = A_objects_3.begin();
    lit != A_objects_3.end();
    lit++)
  {
    CGAL::Object obj = *lit;
    if(const Point_3 *ipoint = CGAL::object_cast<Point_3 >(&obj))
    {
      // Add point
      cdt.insert(P.to_2d(*ipoint));
    } else if(const Segment_3 *iseg = CGAL::object_cast<Segment_3 >(&obj))
    {
      // Add segment constraint
      cdt.insert_constraint(P.to_2d(iseg->vertex(0)),P.to_2d(iseg->vertex(1)));
    } else if(const Triangle_3 *itri = CGAL::object_cast<Triangle_3 >(&obj))
    {
      // Add 3 segment constraints
      cdt.insert_constraint(P.to_2d(itri->vertex(0)),P.to_2d(itri->vertex(1)));
      cdt.insert_constraint(P.to_2d(itri->vertex(1)),P.to_2d(itri->vertex(2)));
      cdt.insert_constraint(P.to_2d(itri->vertex(2)),P.to_2d(itri->vertex(0)));
    } else if(const std::vector<Point_3 > *polyp = 
        CGAL::object_cast< std::vector<Point_3 > >(&obj))
    {
      //cerr<<REDRUM("Poly...")<<endl;
      const std::vector<Point_3 > & poly = *polyp;
      const int m = poly.size();
      assert(m>=2);
      for(int p = 0;p<m;p++)
      {
        const int np = (p+1)%m;
        cdt.insert_constraint(P.to_2d(poly[p]),P.to_2d(poly[np]));
      }
    }else
    {
      cerr<<REDRUM("What is this object?!")<<endl;
      assert(false);
    }
  }
}

#endif