// X2DLeakyPolygon.h
//
//  by Testors , 2005/08/01

#pragma once

#include <vector>
#include <algorithm>
#include <limits>
#include <assert.h>

#include "X2DBasicTypes.h"


namespace X2D
{

	template< typename T = int >
	struct IndexedPoint
	{
		typedef Point< T >			point_t;
		typedef Polygon< T >		owner_t;
		typedef IndexedPoint< T >	this_t;

		struct InputQuadTree {
			X2D::Line< T > operator()( X2D::IndexedPoint< T >* p ) {
				return X2D::Line< T >( p->getPoint(), p->getNextPoint() );
			}
		};

		IndexedPoint() {}
		IndexedPoint( /*const T& _x, const T& _y*/owner_t* _owner, int _index ) 
			: /*Point( _x, _y )
			,*/ owner( _owner )
			, index( _index )
		{
		}
		operator const point_t() const 
		{ 
			return getPoint(); 
		}
		operator point_t()
		{
			return const_cast< point_t& >( getPoint() );
		}
		bool operator ==( const this_t& rhs ) const
		{
			return ( owner == rhs.owner && index == rhs.index );
		}
		bool operator !=( const this_t& rhs ) const
		{
			return ( owner != rhs.owner || index != rhs.index );
		}
		bool operator <( const this_t& rhs ) const
		{
			if( owner < rhs.owner || ( owner == rhs.owner && index < rhs.index ) )
				return true;
			return false;
		}
		const point_t& getPoint() const
		{
			return owner->GetPoint( index );
		}
		size_t getNextIndex() const
		{
			return owner->getNextIndex( index );
		}
		size_t getPrevIndex() const
		{
			return owner->getPrevIndex( index );
		}
		const point_t& getNextPoint() const 
		{ 
			return owner->GetPoint( getNextIndex() );
		}
		const point_t& getPrevPoint() const
		{
			return owner->GetPoint( getPrevIndex() );
		}
		bool isPrevLinked( const this_t& rhs ) const
		{
			if( owner == rhs.owner && owner->getPrevIndex( index ) == rhs.index )
				return true;
			return false;
		}
		bool hasSameOwner( const this_t& rhs ) const
		{
			if( owner == rhs.owner )
				return true;
			return false;
		}
		owner_t*	owner;
		int			index;

		struct Less
		{
			bool operator()( const this_t* lhs, const this_t* rhs ) const
			{
				return *lhs < *rhs;
			}
		};
	};

	template< typename T = int >
	struct LeakyPolygon
	{
		typedef IndexedPoint< T >	Point;
		typedef Line< T >			Line;
		typedef Box< T >			Box;
		typedef Rect< T >			Rect;
				
		LeakyPolygon()
		{
			Clear();
		}

		virtual ~LeakyPolygon()
		{
		}

		LeakyPolygon( const Box & rh )
		{
			Point pt[4];
			pt[0].Set( rh.GetLeft(), rh.GetTop() );
			pt[1].Set( rh.GetRight(), rh.GetTop() );
			pt[2].Set( rh.GetRight(), rh.GetBottom() );
			pt[3].Set( rh.GetLeft(), rh.GetBottom() );
			Set( &pt[0], &pt[4] );
		}

		LeakyPolygon( const LeakyPolygon & rh )
		{
			Set( rh.m_vList.begin(), rh.m_vList.end() );
		}

		template< typename POINT_ITERATOR >
		LeakyPolygon( POINT_ITERATOR begin, POINT_ITERATOR end )
		{
			Set( begin, end );
		}

		template< typename POINT_ITERATOR >
		bool Set( POINT_ITERATOR begin, POINT_ITERATOR end )
		{
			Clear();

			m_vList.reserve( end - begin );

			// 점 생성
			m_vList.assign( begin, end );

			RemoveDuplicatedPoint();

			m_bIsValid = isValid( m_vList );

			if( m_bIsValid ) 
			{
				// 시계방향인지 여부 계산
				m_bIsClockWise = isClockWise();

				// 영역 설정
				calculateArea( m_vList, m_bxArea );
			}
			else
			{
				Clear();
			}

			return m_bIsValid;
		}

		/*
		void operator=( const LeakyPolygon & rh )
		{
			Set( rh.m_vList.begin(), rh.m_vList.end() );
		}*/

		bool Scale( float fScale, bool bAlignCenter = false )
		{
			std::vector< Point > tmpList = m_vList;
			for( std::vector< Point >::iterator it = tmpList.begin(); it != tmpList.end(); ++it )
			{
				(*it).x *= fScale;
				(*it).y *= fScale;
			}
			if( !isValid( tmpList ) ) return false;

			T x_offset;
			T y_offset;

			Box bxArea;
			calculateArea( tmpList, bxArea );

			if( bAlignCenter )
			{
				x_offset = bxArea.GetCenter().x - m_bxArea.GetCenter().x;
				y_offset = bxArea.GetCenter().y - m_bxArea.GetCenter().y;
			}
			else
			{
				x_offset = bxArea.GetLeft() - m_bxArea.GetLeft();
				y_offset = bxArea.GetTop() - m_bxArea.GetTop();
			}

			for( std::vector< Point >::iterator it = tmpList.begin(); it != tmpList.end(); ++it )
			{
				(*it).x -= x_offset;
				(*it).y -= y_offset;
			}

			Set( tmpList.begin(), tmpList.end() );

			return true;
		}

		void Clear()
		{	
			m_vList.erase( m_vList.begin(), m_vList.end() );
			m_bxArea.Set( 0, 0, 0, 0 );
			m_bIsClockWise = false;
			m_bIsValid = false;
		}

		void Reverse()
		{
			if( m_vList.empty() ) return;
			std::reverse( m_vList.begin(), m_vList.end() );
			m_bIsClockWise = !m_bIsClockWise;
		}

		bool IsClockWise() const	{ return m_bIsClockWise; }

		void MakeToClockwise()
		{
			if( !IsClockWise() ) Reverse();
		}

		template< typename GT >
		bool IsIn( const GT & t ) const
		{
			std::vector< Point >::const_iterator it;
			for( it = m_vList.begin(); it != m_vList.end(); ++it )
			{
				if( !t.IsInclude( *it ) ) return false;
			}

			return true;
		}

		bool Has( const Point & pt ) const
		{
			for( std::vector< Point >::const_iterator it = m_vList.begin(); it != m_vList.end(); ++it ) if( *it == pt ) return true;
			return false;
		}

		bool Has( const Line & line ) const
		{
			for( size_t idx = 0; idx < m_vList.size(); ++idx )
			{
				if( GetSegment( idx ) == line ) return true;
			}
			return false;
		}

		const Box & GetBoundingBox() const 
		{ 
			if( m_vList.empty() )
				return m_bxArea;
			return m_vList[ 0 ].owner->GetBoundingBox();
		}

		/** 기본 컨셉은 폴리곤 바깥의 임의의 점과 pt 두개로 구성된 선분이 폴리곤을 이루는 선분들과 
			몇개나 충돌하는지를 검사하고, 홀수이면 포함, 짝수이면 포함이 아니라고 판정하는 것이다. */
		bool IsInclude( const X2D::Point< T > & pt ) const
		{
			if( m_vList.empty() ) return false;
			return m_vList[ 0 ].owner->IsInclude( pt );
		}

		bool IsInclude( const T & x, const T & y ) const	{ return IsInclude( X2D::Point< T >( x, y ) ); }

		bool IsValid() const { return m_bIsValid; }

		Line GetSegment( size_t idx ) const
		{
			assert( idx < m_vList.size() );

			return Line( m_vList[idx], GetNextPoint( idx ) );
		}

		bool operator==( const LeakyPolygon & rh ) const
		{
			assert( IsValid() && rh.IsValid() );

			if( Size() != rh.Size() ) return false;
			
			int    begin = 0;
			int    add = 1;
			if( IsClockWise() != rh.IsClockWise() )
			{
				begin = (int)Size() - 1;
				add   = -1;
			}

			size_t mod = 0;
			std::vector< Point >::const_iterator it;
			for( it = rh.m_vList.begin(); it != rh.m_vList.end(); ++it, ++mod )
			{
				if( m_vList[begin] == *it ) break;
			}

			// 똑같은 점이 하나도 없으면..
			if( it == rh.m_vList.end() ) return false;
			
			int rh_idx = 0;
			for( int idx = begin; idx >= 0 && idx < (int)Size(); idx += add, ++rh_idx )
			{
				if( rh.m_vList[ ( rh_idx + mod ) % rh.Size() ] != m_vList[ idx ] ) return false;
			}

			return true;
		}

		bool IsInclude( const LeakyPolygon & rh ) const
		{
			if( !m_bxArea.IsInclude( rh.m_bxArea ) ) return false;

			std::vector< Point >::const_iterator it;
			for( it = rh.m_vList.begin(); it != rh.m_vList.end(); ++it ) if( !IsInclude( *it ) ) return false;

			// 선분끼리 충돌하면 충돌임
			for( size_t my_idx = 0; my_idx < Size(); ++my_idx )
			{
				for( size_t rh_idx = 0; rh_idx < rh.Size(); ++rh_idx )
				{
					if( GetSegment( my_idx ).IntersectCCW( rh.GetSegment( rh_idx ) ) != Line::SEPARATE ) return false;
				}
			}

			return true;
		}

		bool IsCollision( const X2D::Point< T > & rh ) const	{ return IsInclude( rh ); }
		bool IsCollision( const Box & rh ) const
		{
			LeakyPolygon temp( rh );
			return IsCollision( temp );
		}
		bool IsCollision( const Rect & rc ) const
		{
			// Rect 의 왼쪽 끝점이 폴리곤 안에 있으면 충돌
			if( IsInclude( X2D::Point< T >( rc.GetLeft(), rc.GetTop() ) ) ) return true;

			// 서로 한 점이라도 포함하면 충돌
			for( std::vector< Point >::const_iterator it = m_vList.begin(); it != m_vList.end(); ++it )
			{
				if( INCLUDE( rc, *it ) ) return true;
			}

			X2D::Line< T > line_a( rc.GetLeft(), rc.GetTop(),   rc.GetRight(),rc.GetTop() );
			X2D::Line< T > line_b( rc.GetRight(),rc.GetTop(),   rc.GetRight(),rc.GetBottom() );
			X2D::Line< T > line_c( rc.GetRight(),rc.GetBottom(),rc.GetLeft(), rc.GetBottom() );
			X2D::Line< T > line_d( rc.GetLeft(), rc.GetBottom(),rc.GetLeft(), rc.GetTop() );

			for( size_t my_idx = 0; my_idx < Size(); ++my_idx )
			{
				X2D::Line< T > line = GetSegment( my_idx );	

				X2D::Line< T >::INTERSECT_RESULT result_a, result_b, result_c, result_d;

				// 선분끼리 교차하면 충돌
				if( ( result_a = line.IntersectCCW( line_a ) ) == Line::INTERSECT ) return true;
				if( ( result_b = line.IntersectCCW( line_b ) ) == Line::INTERSECT ) return true;
				if( ( result_c = line.IntersectCCW( line_c ) ) == Line::INTERSECT ) return true;
				if( ( result_d = line.IntersectCCW( line_d ) ) == Line::INTERSECT ) return true;

				if( line.begin.x != line.end.x && line.begin.y != line.end.y )
				{
					if( result_b == Line::TOUCH && result_c == Line::TOUCH ) return true;
				}
			}

			return false;
		}

		bool IsCollision( const X2D::Line<T> & line ) const
		{
			if( IsInclude( line.begin ) || IsInclude( line.end ) ) return true;

			for( size_t my_idx = 0; my_idx < Size(); ++my_idx )
			{
				if( GetSegment( my_idx ).IntersectCCW( line ) != Line::SEPARATE ) return true;
			}

			return false;
		}

		bool IsCollision( const LeakyPolygon & rh ) const
		{
			if( !m_bxArea.IsCollision( rh.m_bxArea ) ) return false;

			// 서로가 한점이라도 포함하고 있으면 충돌임.
			std::vector< Point >::const_iterator it;
			for( it = m_vList.begin(); it != m_vList.end(); ++it ) if( rh.IsInclude( *it ) ) return true;
			for( it = rh.m_vList.begin(); it != rh.m_vList.end(); ++it ) if( IsInclude( *it ) ) return true;

			// 선분끼리 충돌하면 충돌임
			for( size_t my_idx = 0; my_idx < Size(); ++my_idx )
			{
				for( size_t rh_idx = 0; rh_idx < rh.Size(); ++rh_idx )
				{
					if( GetSegment( my_idx ).IntersectCCW( rh.GetSegment( rh_idx ) ) != Line::SEPARATE ) return true;
				}
			}

			return false;
		}

		void RemoveDuplicatedPoint()
		{
			if( !IsValid() ) return;

			Point prevPt								= m_vList.back();
			std::vector< Point >::iterator new_it		= m_vList.begin();
			std::vector< Point >::iterator target_it	= m_vList.begin();

			for( std::vector< Point >::iterator target_it = m_vList.begin(); target_it != m_vList.end(); ++target_it )
			{
				if( target_it == m_vList.begin() ) 
				{
					if( prevPt != *new_it ) new_it++;
					continue;
				}

				if( prevPt == *target_it ) continue;

				*new_it = *target_it; 
				prevPt = *target_it;
				new_it++;
			}

			m_vList.resize( new_it - m_vList.begin() );
		}

		size_t Size() const { return m_vList.size(); }
		const Point &			GetIndxPoint( size_t idx ) const	{ return m_vList[idx]; }
		const X2D::Point< T > & GetPoint( size_t idx ) const		{ return m_vList[idx].getPoint(); }
		const X2D::Point< T > & GetPrevPoint( size_t idx ) const	{ return m_vList[idx].getPrevPoint(); }
		const X2D::Point< T > & GetNextPoint( size_t idx ) const	{ return m_vList[idx].getNextPoint(); }
		const Point * GetRawPoint() const							{ return &m_vList[0]; }
		X2D::Point< T > GetCenter() const
		{
			return m_bxArea.GetCenter();
		}
		bool IsDeadEnd( size_t idx ) const				
		{ 
			if( idx == 0 )
				return GetPrevPoint( idx ) != GetPoint( Size() - 1 );
			else if( idx == ( Size() - 1 ) )
				return GetNextPoint( idx ) != GetPoint( 0 );
			return false;
		}

		const T GetTop() const		{ return m_bxArea.GetTop();		}
		const T GetBottom() const	{ return m_bxArea.GetBottom();	}
		const T GetLeft() const		{ return m_bxArea.GetLeft();	}
		const T GetRight() const	{ return m_bxArea.GetRight();	}

	protected:

		bool isValid( const std::vector< Point > & vList ) const
		{
			//if( vList.size() < 3 ) return false;
			
			// 동일한 점이 있는지 검사
			std::vector< Point >::const_iterator cur_it		= vList.begin();
			std::vector< Point >::const_iterator target_it	= vList.begin();
			for( cur_it = vList.begin(); cur_it != vList.end(); ++cur_it )
			{
				for( target_it = cur_it + 1; target_it != vList.end(); ++target_it )
				{
					if( (*target_it) == (*cur_it) ) return false;
				}
			}

			// 선분이 서로 충돌하는지 검사
			for( size_t idx_1 = 0; idx_1 < vList.size(); ++idx_1 )
			{
				for( size_t idx_2 = idx_1 + 1; idx_2 < vList.size(); ++idx_2 )
				{
					const Point& pt1 = GetIndxPoint( idx_1 );
					const Point& pt2 = GetIndxPoint( idx_2 );

					/*size_t p1 = GetPoint( idx_1 ).index;
					size_t p2 = GetPoint( idx_1 ).owner->getNextIndex( GetPoint( idx_1 ).index ); getNextIndex(idx_1);
					size_t p3 = idx_2;
					size_t p4 = getNextIndex(idx_2);*/

					Line::INTERSECT_RESULT nResult = Line::IntersectCCW( pt1, pt1.getNextPoint(), pt2, pt2.getNextPoint() );					

					if( nResult == Line::INTERSECT ) return false;
					if( nResult == Line::TOUCH && pt1.getNextIndex() != pt2.index && pt1.index != pt2.getNextIndex() ) return false;
				}
			}

			return true;
		}

		bool isClockWise() const
		{
			if( !m_vList.empty() )
				return m_vList[ 0 ].owner->IsClockWise();

			// x 가 가장 작은 점을 찾는다		
			size_t mid_idx = 0;
			for( size_t i = 0; i < m_vList.size(); ++i ) 
			{
				if( m_vList[ mid_idx ].getPoint().x > m_vList[i].getPoint().x ) mid_idx = i;
			}

			int nCCWResult = X2D::CLOCK_WISE;

			size_t cnt = 0;
			while( true )
			{
				const X2D::Point< T >& prevPt = GetPrevPoint( mid_idx );
				const X2D::Point< T >& nextPt = GetNextPoint( mid_idx );

				nCCWResult = X2D::CheckClockWise( 
					prevPt.x, prevPt.y, 
					m_vList[mid_idx].getPoint().x, m_vList[mid_idx].getPoint().y,
					nextPt.x, nextPt.y );

				if( nCCWResult != PARALLELISM ) break;

				assert( mid_idx < m_vList.size() );

				++mid_idx;
				++cnt;
				if( cnt > m_vList.size() ) break;

				if( mid_idx == m_vList.size() ) mid_idx = 0;
			}

			return ( nCCWResult == CLOCK_WISE );
		}

		void loop()
		{
			for( size_t idx = 0; idx < m_vList.size(); ++idx )
			{
				// do( idx, getNextIndex( idx ) );
			}
		}

		void calculateArea( const std::vector< Point > & vList, Box & area )
		{
			std::vector< Point >::const_iterator it;

			area.Set( vList.front(), vList.front() );
			for( it = vList.begin(); it != vList.end(); ++it )
			{
				if( (*it).getPoint().x < area.GetLeft()		) area.SetLeft( (*it).getPoint().x );
				if( (*it).getPoint().y < area.GetTop()		) area.SetTop( (*it).getPoint().y );
				if( (*it).getPoint().x > area.GetRight()	) area.SetRight( (*it).getPoint().x );
				if( (*it).getPoint().y > area.GetBottom()	) area.SetBottom( (*it).getPoint().y );
			}
		}

		bool						m_bIsValid;
		bool						m_bIsClockWise;		///< 점 순서가 시계방향인지 여부
		std::vector< Point >		m_vList;
		Box							m_bxArea;			///< 포함체크등에서 박스체크를 선행해서 속도 이득을 볼 수 있는 경우가 많으므로 미리 계산해 놓는다.
	};

	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Point<T>   		& rh )	{ return lh.IsInclude( rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Box<T>     		& rh )	{ return lh.IsInclude( rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Rect<T>    		& rh )	{ return lh.IsInclude( rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Line<T>    		& rh )	{ return lh.IsInclude( rh.begin ) && lh.IsInclude( rh.end );	}
	template< typename T > inline bool INCLUDE(   const Line<T>			& lh, const LeakyPolygon<T> & rh )	{ return false;					}
	template< typename T > inline bool INCLUDE(	  const Rect<T>    		& lh, const LeakyPolygon<T> & rh )	{ return rh.IsIn( lh );			}
	template< typename T > inline bool INCLUDE(	  const Box<T>     		& lh, const LeakyPolygon<T> & rh )	{ return rh.IsIn( lh );			}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const LeakyPolygon<T> & rh )	{ return lh.IsInclude( rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Point<T>		& rh )	{ return lh.IsCollision( rh );	}
	template< typename T > inline bool COLLISION( const Point<T>		& lh, const LeakyPolygon<T> & rh )	{ return rh.IsInclude( lh);		}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Box<T>     		& rh )	{ return lh.IsCollision( rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Rect<T>    		& rh )	{ return lh.IsCollision( rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Line<T>    		& rh )	{ return lh.IsCollision( rh );	}
	template< typename T > inline bool COLLISION( const Line<T>    		& lh, const LeakyPolygon<T> & rh )	{ return rh.IsCollision( lh );	}
	template< typename T > inline bool COLLISION( const Box<T>     		& lh, const LeakyPolygon<T> & rh )	{ return COLLISION( rh, lh );	}
	template< typename T > inline bool COLLISION( const Rect<T>    		& lh, const LeakyPolygon<T> & rh )	{ return COLLISION( rh, lh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const LeakyPolygon<T> & rh )	{ return lh.IsCollision( rh );	}
	template< typename T > inline bool COLLISION( const IndexedPoint<T> & lh, const Point<T>		& rh )  { return lh.owner->IsCollision( rh ); }
	template< typename T > inline bool COLLISION( const Point<T>		& lh, const IndexedPoint<T> & rh )  { return rh.owner->IsCollision( lh ); }
	template< typename T > inline bool COLLISION( const IndexedPoint<T> & lh, const Rect<T>			& rh )  { return lh.owner->IsCollision( rh ); }
	template< typename T > inline bool COLLISION( const Rect<T>			& lh, const IndexedPoint<T> & rh )  { return rh.owner->IsCollision( lh ); }


	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const Point<T>   		& rh )	{ return INCLUDE( *lh, rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const Box<T>     		& rh )	{ return INCLUDE( *lh, rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const Rect<T>    		& rh )	{ return INCLUDE( *lh, rh );	}
	template< typename T > inline bool INCLUDE(	  const Rect<T>    		* lh, const LeakyPolygon<T> & rh )	{ return INCLUDE( *lh, rh );	}
	template< typename T > inline bool INCLUDE(	  const Box<T>     		* lh, const LeakyPolygon<T> & rh )	{ return INCLUDE( *lh, rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const LeakyPolygon<T> & rh )	{ return INCLUDE( *lh, rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Point<T>		& rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const Point<T>		* lh, const LeakyPolygon<T> & rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Box<T>     		& rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Rect<T>    		& rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Line<T>    		& rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const Box<T>     		* lh, const LeakyPolygon<T> & rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const Rect<T>    		* lh, const LeakyPolygon<T> & rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const Line<T>    		* lh, const LeakyPolygon<T> & rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const LeakyPolygon<T> & rh )	{ return COLLISION( *lh, rh );	}
	template< typename T > inline bool COLLISION( const IndexedPoint<T> * lh, const Point<T>		& rh )  { return (*lh).owner->IsCollision( rh ); }
	template< typename T > inline bool COLLISION( const Point<T>		* lh, const IndexedPoint<T> & rh )  { return rh.owner->IsCollision( *lh ); }
	template< typename T > inline bool COLLISION( const IndexedPoint<T> * lh, const Rect<T>			& rh )  { return (*lh).owner->IsCollision( rh ); }
	template< typename T > inline bool COLLISION( const Rect<T>			* lh, const IndexedPoint<T> & rh )  { return rh.owner->IsCollision( *lh ); }


	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Point<T>   		* rh )	{ return INCLUDE( lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Box<T>     		* rh )	{ return INCLUDE( lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const Rect<T>    		* rh )	{ return INCLUDE( lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const Rect<T>    		& lh, const LeakyPolygon<T> * rh )	{ return INCLUDE( lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const Box<T>     		& lh, const LeakyPolygon<T> * rh )	{ return INCLUDE( lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> & lh, const LeakyPolygon<T> * rh )	{ return INCLUDE( lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Point<T>		* rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const Point<T>		& lh, const LeakyPolygon<T> * rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Box<T>     		* rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Rect<T>    		* rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const Line<T>    		* rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const Box<T>     		& lh, const LeakyPolygon<T> * rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const Rect<T>    		& lh, const LeakyPolygon<T> * rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const Line<T>    		& lh, const LeakyPolygon<T> * rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> & lh, const LeakyPolygon<T> * rh )	{ return COLLISION( lh, *rh );	}
	template< typename T > inline bool COLLISION( const IndexedPoint<T> & lh, const Point<T>		* rh )  { return lh.owner->IsCollision( *rh ); }
	template< typename T > inline bool COLLISION( const Point<T>		& lh, const IndexedPoint<T> * rh )  { return (*rh).owner->IsCollision( lh ); }
	template< typename T > inline bool COLLISION( const IndexedPoint<T> & lh, const Rect<T>			* rh )  { return lh.owner->IsCollision( *rh ); }
	template< typename T > inline bool COLLISION( const Rect<T>			& lh, const IndexedPoint<T> * rh )  { return (*rh).owner->IsCollision( lh ); }


	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const Point<T>   		* rh )	{ return INCLUDE( *lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const Box<T>     		* rh )	{ return INCLUDE( *lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const Rect<T>    		* rh )	{ return INCLUDE( *lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const Rect<T>    		* lh, const LeakyPolygon<T> * rh )	{ return INCLUDE( *lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const Box<T>     		* lh, const LeakyPolygon<T> * rh )	{ return INCLUDE( *lh, *rh );	}
	template< typename T > inline bool INCLUDE(	  const LeakyPolygon<T> * lh, const LeakyPolygon<T> * rh )	{ return INCLUDE( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Point<T>   		* rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const Point<T>		* lh, const LeakyPolygon<T>	* rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Box<T>     		* rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Rect<T>    		* rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const Line<T>    		* rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const Box<T>     		* lh, const LeakyPolygon<T> * rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const Rect<T>    		* lh, const LeakyPolygon<T> * rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const Line<T>    		* lh, const LeakyPolygon<T> * rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const LeakyPolygon<T> * lh, const LeakyPolygon<T> * rh )	{ return COLLISION( *lh, *rh );	}
	template< typename T > inline bool COLLISION( const IndexedPoint<T> * lh, const Point<T>		* rh )  { return (*lh).owner->IsCollision( *rh ); }
	template< typename T > inline bool COLLISION( const Point<T>		* lh, const IndexedPoint<T> * rh )  { return (*rh).owner->IsCollision( *lh ); }
	template< typename T > inline bool COLLISION( const IndexedPoint<T> * lh, const Rect<T>			* rh )  { return (*lh).owner->IsCollision( *rh ); }
	template< typename T > inline bool COLLISION( const Rect<T>			* lh, const IndexedPoint<T> * rh )  { return (*rh).owner->IsCollision( *lh ); }

};	// namespace X2D