hexagon_filtered_predicates.h

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

	  return false;

	for(int j=0;j< hips->size() ;j++)
	  if( (*hips)[j]!=(*bips)[j] )
	    return false;

	hips++;
	bips++;
      }

      return CK().equal_2_object()( a.arc(),b.arc() );

    }

  public:

    result_type
    operator()( const Circular_arc_point_2 &a ,
                const Circular_arc_point_2 &b ) const
	 {  return CK().equal_2_object()(a,b);}

    result_type
    operator()( const Circular_arc_2 &a , const Circular_arc_2 &b ) const
    {
      CGAL_precondition( a.arc().is_x_monotone());
      CGAL_precondition( b.arc().is_x_monotone());
      return _equal_2(a,b);      
    }

    result_type
    operator()( const Line_arc_2 &a ,
                const Line_arc_2 &b ) const
    {  return _equal_2(a,b);}

    result_type
    operator()( const Circular_arc_2 &a ,
                const Line_arc_2 &b ) const
	 {  return false;}

    result_type
    operator()( const Line_arc_2 &a ,
                const Circular_arc_2 &b ) const
	 {  return false;}

};


template <class HK>
class Do_overlap_2
  {
    typedef typename HK::Circular_kernel                                  CK;
    typedef typename HK::Circular_arc_2                                 Circular_arc_2;
    typedef typename HK::Line_arc_2                                     Line_arc_2;

  public:

    typedef bool result_type;

  private:

    template <class Arc_2>
    result_type
    _do_overlap_2(const Arc_2 &a, const Arc_2 &b) const
    {
      if(a.has_no_hexagons())
        a.construct_hexagons();
	
      if(b.has_no_hexagons())
        b.construct_hexagons();

      if(CGALi::do_intersect_hexagons_2( a.hexagons_begin(),a.hexagons_end(),b.hexagons_begin(),b.hexagons_end() ) )
        return CK().do_overlap_2_object()(a.arc(),b.arc());

      return false;
    }


  public:
    
    result_type
    operator()( const Circular_arc_2 &a , const Circular_arc_2 &b ) const
    {
      CGAL_precondition( a.arc().is_x_monotone());
      CGAL_precondition( b.arc().is_x_monotone());
      return _do_overlap_2(a,b); 
    }

    result_type
    operator()( const Line_arc_2 &a ,
                const Line_arc_2 &b ) const
    {  return _do_overlap_2(a,b);}

    result_type
    operator()( const Circular_arc_2 &a ,
                const Line_arc_2 &b ) const
	 {  return false;}

    result_type
    operator()( const Line_arc_2 &a ,
                const Circular_arc_2 &b ) const
	 {  return false;}

};


// This predicate cannot be filtered

 template < class HK >
  class Compare_y_to_right_2
  {
    typedef typename HK::Circular_kernel            CK;
    typedef typename HK::Circular_arc_2           Circular_arc_2;
    typedef typename HK::Circular_arc_point_2  Circular_arc_point_2;

  public:
    typedef Comparison_result result_type;
    
    template <typename T1, typename T2>
    result_type
    operator()(const T1 &a1,
               const T2 &a2,
               const Circular_arc_point_2 &p) const
    { return CK().compare_y_to_right_2_object()(a1.arc(), a2.arc(), p); }
    
  };





  template < class HK >
  class Make_x_monotone_2
  {
    typedef typename HK::Circular_kernel            CK;
    typedef typename HK::Rcirc_arc_2              Rcirc_arc_2;
    typedef typename HK::Circular_arc_2       	  Circular_arc_2;
    typedef typename HK::Line_arc_2               Line_arc_2;

  public:
    // typedef OutputIterator result_type;

    template < class OutputIterator >
    OutputIterator
    operator()(const Circular_arc_2 &A, OutputIterator res)
      { 
	std::vector<Object> vec;
	
	CK().make_x_monotone_2_object()(A.arc(), std::back_inserter(vec) );
 
	for(unsigned i=0; i<vec.size() ; i++)
	{
	  const Rcirc_arc_2 *tmp_arc;

	  tmp_arc=object_cast<Rcirc_arc_2>(&vec.at(i));
		
	  assert(tmp_arc!=NULL);
		
	  *res++ = make_object( Circular_arc_2(*tmp_arc) );
	}

	return res;
      }
    
    template < class OutputIterator >
    OutputIterator
    operator()(const Line_arc_2 &A, OutputIterator res)
      { 
	*res++ = make_object(A);
	return res;
      }
  };


  template < class HK >
  class Intersect_2
  {
    public:

    typedef typename HK::Circular_kernel            CK;
    typedef typename HK::Circular_arc_2           Circular_arc_2;
    typedef typename HK::Rcirc_arc_2              Rcirc_arc_2;
    typedef typename HK::Rline_arc_2              Rline_arc_2;
    typedef typename HK::Circle_2                 Circle;
    typedef typename HK::Line_arc_2               Line_arc_2;

    template < class OutputIterator >
    OutputIterator
    operator()(const Circle & c1, const Circle & c2, OutputIterator res)
      { return CK().intersect_2_object()(c1,c2,res); }

     template < class OutputIterator >
    OutputIterator
    operator()(const Circular_arc_2 & c1, const Circular_arc_2 & c2, 
	       OutputIterator res)
      { 
        if(c1.has_no_hexagons())
          c1.construct_hexagons();

        if(c2.has_no_hexagons())
          c2.construct_hexagons();

        if(!CGALi::do_intersect_hexagons_2(c1.hexagons_begin(),c1.hexagons_end(),
	                                   c2.hexagons_begin(),c2.hexagons_end()) )
         return res;

	std::vector<Object> vec;
	
	CK().intersect_2_object()(c1.arc(),c2.arc(),std::back_inserter(vec)); 

 	for(unsigned i=0; i<vec.size() ; i++)
	{
	  const Rcirc_arc_2 *tmp_arc;

	  if ( (tmp_arc=object_cast<Rcirc_arc_2>(&vec.at(i)) )!=NULL )
	    *res++ = make_object( Circular_arc_2(*tmp_arc) );
	  else
	    *res++ = vec.at(i);
	}
	
	return res;
	

      }

     template < class OutputIterator >
    OutputIterator
    operator()(const Line_arc_2 & c1, const Line_arc_2 & c2, 
	       OutputIterator res)
      { 
        if(c1.has_no_hexagons())
          c1.construct_hexagons();

        if(c2.has_no_hexagons())
          c2.construct_hexagons();

        if(!CGALi::do_intersect_hexagons_2(c1.hexagons_begin(),c1.hexagons_end(),c2.hexagons_begin(),c2.hexagons_end()) )
         return res;


	std::vector<Object> vec;
	
	CK().intersect_2_object()(c1.arc(),c2.arc(),std::back_inserter(vec)); 

 	for(unsigned i=0; i<vec.size() ; i++)
	{
	  const Rline_arc_2 *tmp_arc;

	  if ( (tmp_arc=object_cast<Rline_arc_2>(&vec.at(i)) )!=NULL )
	    *res++ = make_object( Line_arc_2(*tmp_arc) );
	  else
	    *res++ = vec.at(i);
	}
	
	return res;	
      }

     template < class OutputIterator >
    OutputIterator
    operator()(const Circular_arc_2 & c1, const Line_arc_2 & c2, 
	       OutputIterator res)
      { 
        if(c1.has_no_hexagons())
          c1.construct_hexagons();

        if(c2.has_no_hexagons())
          c2.construct_hexagons();

        if(!CGALi::do_intersect_hexagons_2(c1.hexagons_begin(),c1.hexagons_end(),c2.hexagons_begin(),c2.hexagons_end()) )
         return res;


	std::vector<Object> vec;
	
	CK().intersect_2_object()(c1.arc(),c2.arc(),std::back_inserter(vec)); 

 	for(unsigned i=0; i<vec.size() ; i++)
	{
	  const Rcirc_arc_2 *tmp_arc;
	  const Rline_arc_2 *tmp_line;

	  if ( (tmp_arc=object_cast<Rcirc_arc_2>(&vec.at(i)) )!=NULL )
	    *res++ = make_object( Circular_arc_2(*tmp_arc) );
	  else if ( (tmp_line=object_cast<Rline_arc_2>(&vec.at(i)) )!=NULL )
	    *res++ = make_object( Line_arc_2(*tmp_line) );
	  else
	    *res++ = vec.at(i);
	}

	return res;	

      }

      template < class OutputIterator >
    OutputIterator
    operator()(const Line_arc_2 & c1, const Circular_arc_2 & c2, 
	       OutputIterator res)
      {
	return operator()(c2,c1,res);
      }
     
    
  };


  template < class HK >
  class Split_2
  {

    typedef typename HK::Circular_kernel            CK;
    typedef typename HK::Rcirc_arc_2              Rcirc_arc_2;
    typedef typename HK::Rline_arc_2              Rline_arc_2;
    typedef typename HK::Circular_arc_2           Circular_arc_2;
    typedef typename HK::Line_arc_2               Line_arc_2;
    typedef typename HK::Circular_arc_point_2  Circular_arc_point_2;

  public:
    typedef void result_type;

    result_type
    operator()(const Circular_arc_2 &A, 
	       const Circular_arc_point_2 &p,
	       Circular_arc_2 &ha1, Circular_arc_2 &ha2) const
    {  
      Rcirc_arc_2 ca1 , ca2;

      CK().split_2_object()(A.arc(), p, ca1, ca2);

      ha1=Circular_arc_2(ca1); 
      ha2=Circular_arc_2(ca2); 
    }
    
    result_type
    operator()(const Line_arc_2 &A, 
	       const Circular_arc_point_2 &p,
	       Line_arc_2 &ha1, Line_arc_2 &ha2) const
    {  
      Rline_arc_2 ca1 , ca2;

      CK().split_2_object()(A.arc(), p, ca1, ca2);

      ha1=Line_arc_2(ca1); 
      ha2=Line_arc_2(ca2); 
    }
    
  };


  
} //Hexagon_functors

CGAL_END_NAMESPACE  

#endif // CGAL_HEXAGON_FILTERED_PREDICATES_H