koffice/karbon/core/vpath.cpp

/* This file is part of the KDE project
   Copyright (C) 2002, The Karbon Developers

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/


#include <math.h>

#include <tqdom.h>
#include <tqvaluelist.h>
#include <tqwmatrix.h>

#include "vpath.h"
#include "vsegment.h"
#include "vvisitor.h"

#include <kdebug.h>


class VSubpathIteratorList
{
public:
	VSubpathIteratorList()
			: m_list( 0L ), m_iterator( 0L )
	{}

	~VSubpathIteratorList()
	{
		notifyClear( true );
		delete m_list;
	}

	void add( VSubpathIterator* itr )
	{
		if( !m_iterator )
			m_iterator = itr;
		else if( m_list )
			m_list->push_front( itr );
		else
		{
			m_list = new TQValueList<VSubpathIterator*>;
			m_list->push_front( itr );
		}
	}

	void remove( VSubpathIterator* itr )
	{
		if( m_iterator == itr )
			m_iterator = 0L;
		else if( m_list )
		{
			m_list->remove( itr );

			if( m_list->isEmpty() )
			{
				delete m_list;
				m_list = 0L;
			}
		}
	}

	void notifyClear( bool zeroList )
	{
		if( m_iterator )
		{
			if( zeroList )
				m_iterator->m_list = 0L;

			m_iterator->m_current = 0L;
		}

		if( m_list )
		{
			for(
				TQValueList<VSubpathIterator*>::Iterator itr = m_list->begin();
				itr != m_list->end();
				++itr )
			{
				if( zeroList )
					( *itr )->m_list = 0L;

				( *itr )->m_current = 0L;
			}
		}
	}

	void notifyRemove( VSegment* segment, VSegment* current )
	{
		if( m_iterator )
		{
			if( m_iterator->m_current == segment )
				m_iterator->m_current = current;
		}

		if( m_list )
		{
			for(
				TQValueList<VSubpathIterator*>::Iterator itr = m_list->begin();
				itr != m_list->end();
				++itr )
			{
				if( ( *itr )->m_current == segment )
					( *itr )->m_current = current;
			}
		}
	}

private:
	TQValueList<VSubpathIterator*>* m_list;
	VSubpathIterator* m_iterator;
};


VSubpath::VSubpath( VObject* parent )
		: VObject( parent )
{
	m_isClosed = false;

	m_first = m_last = m_current = 0L;
	m_number = 0;
	m_currentIndex = -1;
	m_iteratorList = 0L;

	// Add an initial segment.
	append( new VSegment( 1 ) );
}

VSubpath::VSubpath( const VSubpath& list )
		: VObject( list )
{
	m_isClosed = list.isClosed();

	m_first = m_last = m_current = 0L;
	m_number = 0;
	m_currentIndex = -1;
	m_iteratorList = 0L;

	VSegment* segment = list.m_first;

	while( segment )
	{
		append( segment->clone() );
		segment = segment->m_next;
	}
}

VSubpath::VSubpath( const VSegment& segment )
		: VObject( 0L )
{
	m_isClosed = false;

	m_first = m_last = m_current = 0L;
	m_number = 0;
	m_currentIndex = -1;
	m_iteratorList = 0L;

	// The segment is not a "begin" segment.
	if( segment.prev() )
	{
		// Add an initial segment.
		append( new VSegment( 1 ) );

		// Move the "begin" segment to the new segment's previous knot.
		moveTo( segment.prev()->knot() );
	}

	// Append a copy of the segment.
	append( segment.clone() );
}

VSubpath::~VSubpath()
{
	clear();
	delete m_iteratorList;
}

const KoPoint&
VSubpath::currentPoint() const
{
	return getLast()->knot();
}

bool
VSubpath::moveTo( const KoPoint& p )
{
	// Move "begin" segment if path is still empty.
	if( isEmpty() )
	{
		getLast()->setKnot( p );
		return true;
	}

	return false;
}

bool
VSubpath::lineTo( const KoPoint& p )
{
	if( isClosed() )
		return false;

	VSegment* s = new VSegment( 1 );

	s->setDegree( 1 );
	s->setKnot( p );

	append( s );

	return true;
}

bool
VSubpath::curveTo(
	const KoPoint& p1, const KoPoint& p2, const KoPoint& p3 )
{
	if( isClosed() )
		return false;

	VSegment* s = new VSegment();

	s->setDegree( 3 );
	s->setPoint( 0, p1 );
	s->setPoint( 1, p2 );
	s->setPoint( 2, p3 );

	append( s );


	return true;
}

bool
VSubpath::curve1To( const KoPoint& p2, const KoPoint& p3 )
{
	if( isClosed() )
		return false;

	VSegment* s = new VSegment();

	s->setDegree( 3 );
	s->setPoint( 0, currentPoint() );
	s->setPoint( 1, p2 );
	s->setPoint( 2, p3 );

	append( s );


	return true;
}

bool
VSubpath::curve2To( const KoPoint& p1, const KoPoint& p3 )
{
	if( isClosed() )
		return false;

	VSegment* s = new VSegment();

	s->setDegree( 3 );
	s->setPoint( 0, p1 );
	s->setPoint( 1, p3 );
	s->setPoint( 2, p3 );

	append( s );


	return true;
}

bool
VSubpath::arcTo(
	const KoPoint& p1, const KoPoint& p2, const double r )
{
	/* This routine is inspired by code in GNU ghostscript.
	 *
	 *           |- P1B3 -|
	 *
	 *          |- - - T12- - -|
	 *
	 *  -   - P1 x....__--o.....x P2
	 *  |   |    :  _/    B3
	 * P1B0      : /
	 *      |    :/
	 *  |        |
	 *  -  T10   o B0
	 *           |
	 *      |    |
	 *           |
	 *      |    |
	 *      -    x P0
	 */

	if( isClosed() || r < 0.0 )
		return false;


	// We need to calculate the tangent points. Therefore calculate tangents
	// T10=P1P0 and T12=P1P2 first.
	double dx0 = currentPoint().x() - p1.x();
	double dy0 = currentPoint().y() - p1.y();
	double dx2 = p2.x() - p1.x();
	double dy2 = p2.y() - p1.y();

	// Calculate distance squares.
	double dsqT10 = dx0 * dx0 + dy0 * dy0;
	double dsqT12 = dx2 * dx2 + dy2 * dy2;

	// We now calculate tan(a/2) where a is the angle between T10 and T12.
	// We benefit from the facts T10*T12 = |T10|*|T12|*cos(a),
	// |T10xT12| = |T10|*|T12|*sin(a) (cross product) and tan(a/2) = sin(a)/[1-cos(a)].
	double num = dy0 * dx2 - dy2 * dx0;

	double denom = sqrt( dsqT10 * dsqT12 ) - ( dx0 * dx2 + dy0 * dy2 );

	// The points are colinear.
	if( 1.0 + denom == 1.0 )
	{
		// Just add a line.
		lineTo( p1 );
	}
	else
	{
		// |P1B0| = |P1B3| = r * tan(a/2).
		double dP1B0 = fabs( r * num / denom );

		// B0 = P1 + |P1B0| * T10/|T10|.
		KoPoint b0 = p1 + KoPoint( dx0, dy0 ) * ( dP1B0 / sqrt( dsqT10 ) );

		// If B0 deviates from current point P0, add a line to it.
		if( !b0.isNear( currentPoint(), VGlobal::isNearRange ) )
			lineTo( b0 );

		// B3 = P1 + |P1B3| * T12/|T12|.
		KoPoint b3 = p1 + KoPoint( dx2, dy2 ) * ( dP1B0 / sqrt( dsqT12 ) );


		// The two bezier-control points are located on the tangents at a fraction
		// of the distance[ tangent points <-> tangent intersection ].
		const KoPoint d = p1 - b0;

		double distsq = d * d;

		double rsq = r * r;

		double fract;

		// r is very small.
		if( distsq >= rsq * VGlobal::veryBigNumber )
		{
			// Assume dist = r = 0.
			fract = 0.0;
		}
		else
		{
			fract = ( 4.0 / 3.0 ) / ( 1.0 + sqrt( 1.0 + distsq / rsq ) );
		}

		KoPoint b1 = b0 + ( p1 - b0 ) * fract;
		KoPoint b2 = b3 + ( p1 - b3 ) * fract;

		// Finally add the bezier-segment.
		curveTo( b1, b2, b3 );
	}

	return true;
}

void
VSubpath::close()
{
	// In the case the list is 100% empty (which should actually never happen),
	// append a "begin" first, to avoid a crash.
	if( count() == 0 )
		append( new VSegment( 1 ) );

	// Move last segment if we are already closed.
	if( isClosed() )
	{
		getLast()->setKnot( getFirst()->knot() );
	}
	// Append a line, if necessary.
	else
	{
		if(
			getLast()->knot().isNear(
				getFirst()->knot(), VGlobal::isNearRange ) )
		{
			// Move last knot.
			getLast()->setKnot( getFirst()->knot() );
		}
		else
		{
			// Add a line.
			lineTo( getFirst()->knot() );
		}

		m_isClosed = true;
	}
}

bool
VSubpath::pointIsInside( const KoPoint& p ) const
{
	// If the point is not inside the boundingbox, it cannot be inside the path either.
	if( !boundingBox().contains( p ) )
		return false;

	// First check if the point is inside the knot polygon (beziers are treated
	// as lines).

	/* This algorithm is taken from "Fast Winding Number Inclusion of a Point
	 * in a Polygon" by Dan Sunday, geometryalgorithms.com.
	 */

	/*
	int windingNumber = 0;

	// Ommit first segment.
	VSegment* segment = getFirst()->next();

	while( segment )
	{
		if( segment->prev()->knot().y() <= p.y() )
		{
			// Upward crossing.
			if( segment->knot().y() > p.y() )
			{
				// Point is left.
				if( segment->pointIsLeft( p ) > 0 )
				{
					// Valid up intersection.
					++windingNumber;
				}
			}
		}
		else
		{
			// Downward crossing.
			if( segment->knot().y() <= p.y() )
			{
				// Point is right.
				if( segment->pointIsLeft( p ) < 0 )
				{
					// Valid down intersection.
					--windingNumber;
				}
			}
		}

		segment = segment->next();
	}

	if( static_cast<bool>( windingNumber ) )
		return true;
	*/
	
	// Then check if the point is located in between the knot polygon
	// and the bezier curves.

	/* We rotate each segment in order to make their chord (the line between
	 * the previous knot and the knot ) parallel to the x-axis. Then we
	 * calculate y(xp) on the segment for the rotated input point (xp,yp)
	 * and compare y(xp) with yp.
	 */
// TODO
	
	// cache the closed evaluation
	bool closed = isClosed() || getLast()->knot() == getFirst()->knot();

	TQValueList<double> rparams;

	VSegment* segment = getFirst()->next();

	// move all segements so that p is the origin 
	// and compute their intersections with the x-axis
	while( segment )
	{
		VSubpath tmpCurve( 0L );
		tmpCurve.append( new VSegment( segment->degree() ) );
	
		for( int i = 0; i <= segment->degree(); ++i )
			tmpCurve.current()->setP(i, segment->p(i)-p );
		
		tmpCurve.current()->rootParams( rparams );

		segment = segment->next();
	}
	
	// if the path is not closed, compute the intersection of
	// the line through the first and last knot and the x-axis too
	if( ! closed )
	{
		KoPoint prevKnot = getLast()->knot() - p;
		KoPoint nextKnot = getFirst()->knot() - p;

		double dx = nextKnot.x() - prevKnot.x();
		double dy = nextKnot.y() - prevKnot.y();
		if( dx == 0.0 )
		{
			rparams.append( nextKnot.x() );
		}
		else if( dy != 0.0 )
		{
			if( ( prevKnot.y() < 0.0 && nextKnot.y() > 0.0 ) || ( prevKnot.y() > 0.0 && nextKnot.y() < 0.0 ) )
			{
				double n = prevKnot.y() - dy / dx * prevKnot.x();
				rparams.append( -n * dx / dy );
			}
		}
	}
	
	kdDebug(38000) << "intersection count: " << rparams.count() << endl;

	// sort all intersections
	qHeapSort( rparams );

	TQValueList<double>::iterator itr, etr = rparams.end();
	
	for( itr = rparams.begin(); itr != etr; ++itr )
		kdDebug(38000) << "intersection: " << *itr << endl;

	if( closed )
	{
		// pair the intersections and check if the origin is within a pair
		for( itr = rparams.begin(); itr != etr; ++itr )
		{
			if( *itr > 0.0 ) 
				return false;
	
			if( ++itr == etr )
				return false;
			
			if( *itr > 0.0 )
				return true;
		}
	}
	else
	{
		// only check if point is between first and last intersection if we have an open path
		if ( rparams.front() < 0.0 && rparams.back() > 0.0 )
			return true;
	}

	return false;
}

bool
VSubpath::intersects( const VSegment& s ) const
{
	// Check if path is empty and if boundingboxes intersect.
	if(
		isEmpty() ||
		!boundingBox().intersects( s.boundingBox() ) )
	{
		return false;
	}


	// Ommit first segment.
	VSegment* segment = getFirst()->next();

	while( segment )
	{
		if( segment->intersects( s ) )
		{
			return true;
		}

		segment = segment->next();
	}

	return false;
}

bool
VSubpath::counterClockwise() const
{
	/* This algorithm is taken from the FAQ of comp.graphics.algorithms:
	 * "Find the lowest vertex (or, if there is more than one vertex with the
	 * same lowest coordinate, the rightmost of those vertices) and then take
	 * the cross product of the edges fore and aft of it."
	 */

	// A non closed path does not have a winding.
	if( !isClosed() )
	{
		return false;
	}


	VSegment* segment = getFirst();

	// We save the segment not the knot itself. Initialize it with the
	// first segment:
	const VSegment* bottomRight = getFirst();

	while( segment )
	{
		if( segment->knot().y() < bottomRight->knot().y() )
			bottomRight = segment;
		else if( segment->knot().y() - bottomRight->knot().y()
				  < VGlobal::isNearRange )
		{
			if( segment->knot().x() > bottomRight->knot().x() )
				bottomRight = segment;
		}

		segment = segment->next();
	}


	// Catch boundary case (bottomRight is first or last segment):
	const VSegment* current;
	const VSegment* next;

	if( bottomRight == getFirst() )
		current = getLast();
	else
		current = bottomRight;

	if( bottomRight == getLast() )
		next = getFirst()->next();
	else
		next = bottomRight->next();

	// Check "z-component" of cross product:
	return
		( next->knot().x() - next->prev()->knot().x() ) *
		( current->knot().y() - current->prev()->knot().y() )
		-
		( next->knot().y() - next->prev()->knot().y() ) *
		( current->knot().x() - current->prev()->knot().x() ) < 0.0;
}

void
VSubpath::revert()
{
	// Catch case where the list is "empty".
	if( isEmpty() )
		return;


	VSubpath list( parent() );
	list.moveTo( getLast()->knot() );

	VSegment* segment = getLast();

	while( segment->prev() )
	{
		list.append( segment->revert() );
		segment = segment->prev();
	}

	list.m_isClosed = isClosed();

	*this = list;
}

const KoRect&
VSubpath::boundingBox() const
{
	if( m_boundingBoxIsInvalid )
	{
		// Reset the boundingbox.
		m_boundingBox = KoRect();

		VSegment* segment = m_first;

		while( segment )
		{
			if( segment->state() != VSegment::deleted )
				m_boundingBox |= segment->boundingBox();

			segment = segment->m_next;
		}

		m_boundingBoxIsInvalid = false;
	}

	return m_boundingBox;
}

VSubpath*
VSubpath::clone() const
{
	return new VSubpath( *this );
}

void
VSubpath::saveSvgPath( TQString &d ) const
{
	// Save segments.
	VSegment* segment = getFirst();

	while( segment )
	{
		if( segment->state() == VSegment::normal )
		{
			if( segment->degree() <= 2 )
			{
				// Line.
				if( segment->prev() )
				{
					d += TQString( "L%1 %2" ).
							arg( segment->knot().x() ).arg( segment->knot().y() );
				}
				// Moveto.
				else
				{
					d += TQString( "M%1 %2" ).
							arg( segment->knot().x() ).arg( segment->knot().y() );
				}
			}
			// Bezier ( degree >= 3 ).
			else
			{
				// We currently treat all beziers as cubic beziers.
				d += TQString( "C%1 %2 %3 %4 %5 %6" ).
							arg( segment->point( segment->degree() - 3 ).x() ).
							arg( segment->point( segment->degree() - 3 ).y() ).
							arg( segment->point( segment->degree() - 2 ).x() ).
							arg( segment->point( segment->degree() - 2 ).y() ).
							arg( segment->knot().x() ).
							arg( segment->knot().y() );
			}
		}

		segment = segment->m_next;
	}

	if( isClosed() )
		d += "Z";
}

// TODO: remove this backward compatibility function after koffice 1.3.x
void
VSubpath::load( const TQDomElement& element )
{
	// We might have a "begin" segment.
	clear();

	TQDomNodeList list = element.childNodes();

	for( uint i = 0; i < list.count(); ++i )
	{
		if( list.item( i ).isElement() )
		{
			TQDomElement segment = list.item( i ).toElement();

			VSegment* s = new VSegment();
			s->load( segment );
			append( s );
		}
	}

	if( element.attribute( "isClosed" ) == 0 ? false : true )
		close();
}

void
VSubpath::accept( VVisitor& visitor )
{
	visitor.visitVSubpath( *this );
}


VSubpath&
VSubpath::operator=( const VSubpath& list )
{
	if( this == &list )
		return *this;

	m_isClosed = list.isClosed();

	clear();

	VSegment* segment = list.m_first;

	while( segment )
	{
		append( segment->clone() );
		segment = segment->m_next;
	}

	m_current = m_first;
	m_currentIndex = 0;

	return *this;
}

bool
VSubpath::insert( const VSegment* segment )
{
	if( m_currentIndex == -1 )
		return false;

	VSegment* s = const_cast<VSegment*>( segment );

	VSegment* prev = m_current->m_prev;

	m_current->m_prev = s;
	prev->m_next = s;
	s->m_prev = prev;
	s->m_next = m_current;

	m_current = s;
	++m_number;

	invalidateBoundingBox();

	return true;
}

bool
VSubpath::insert( uint index, const VSegment* segment )
{
	VSegment* s = const_cast<VSegment*>( segment );

	if( index == 0 )
	{
		prepend( s );
		return true;
	}
	else if( index == m_number )
	{
		append( s );
		return true;
	}

	VSegment* next = locate( index );

	if( !next )
		return false;

	VSegment* prev = next->m_prev;

	next->m_prev = s;
	prev->m_next = s;
	s->m_prev = prev;
	s->m_next = next;

	m_current = s;
	++m_number;

	invalidateBoundingBox();

	return true;
}

void
VSubpath::prepend( const VSegment* segment )
{
	VSegment* s = const_cast<VSegment*>( segment );

	s->m_prev = 0L;

	if( ( s->m_next = m_first ) )
		m_first->m_prev = s;
	else
		m_last = s;

	m_first = m_current = s;

	++m_number;
	m_currentIndex = 0;

	invalidateBoundingBox();
}

void
VSubpath::append( const VSegment* segment )
{
	VSegment* s = const_cast<VSegment*>( segment );

	s->m_next = 0L;

	if( ( s->m_prev = m_last ) )
		m_last->m_next = s;
	else
		m_first = s;

	m_last = m_current = s;

	m_currentIndex = m_number;
	++m_number;

	invalidateBoundingBox();
}

void
VSubpath::clear()
{
	VSegment* segment = m_first;

	m_first = m_last = m_current = 0L;
	m_number = 0;
	m_currentIndex = -1;

	if( m_iteratorList )
		m_iteratorList->notifyClear( false );

	VSegment* prev;

	while( segment )
	{
		prev = segment;
		segment = segment->m_next;
		delete prev;
	}

	m_isClosed = false;

	invalidateBoundingBox();
}

VSegment*
VSubpath::first()
{
	if( m_first )
	{
		m_currentIndex = 0;
		return m_current = m_first;
	}

	return 0L;
}

VSegment*
VSubpath::last()
{
	if( m_last )
	{
		m_currentIndex = m_number - 1;
		return m_current = m_last;
	}

	return 0L;
}

VSegment*
VSubpath::prev()
{
	if( m_current )
	{
		if( m_current->m_prev )
		{
			--m_currentIndex;
			return m_current = m_current->m_prev;
		}

		m_currentIndex = -1;
		m_current = 0L;
	}

	return 0L;
}

VSegment*
VSubpath::next()
{
	if( m_current )
	{
		if( m_current->m_next )
		{
			++m_currentIndex;
			return m_current = m_current->m_next;
		}

		m_currentIndex = -1;
		m_current = 0L;
	}

	return 0L;
}

VSegment*
VSubpath::locate( uint index )
{
	if( index == static_cast<uint>( m_currentIndex ) )
		return m_current;

	if( !m_current && m_first )
	{
		m_current = m_first;
		m_currentIndex = 0;
	}

	VSegment* segment;
	int distance = index - m_currentIndex;
	bool forward;

	if( index >= m_number )
		return 0L;

	if( distance < 0 )
		distance = -distance;

	if(
		static_cast<uint>( distance ) < index &&
		static_cast<uint>( distance ) < m_number - index )
	{
		segment = m_current;
		forward = index > static_cast<uint>( m_currentIndex );
	}
	else if( index < m_number - index )
	{
		segment = m_first;
		distance = index;
		forward = true;
	}
	else
	{
		segment = m_last;
		distance = m_number - index - 1;
		if( distance < 0 )
			distance = 0;
		forward = false;
	}

	if( forward )
	{
		while( distance-- )
			segment = segment->m_next;
	}
	else
	{
		while( distance-- )
			segment = segment->m_prev;
	}

	m_currentIndex = index;
	return m_current = segment;
}


VSubpathIterator::VSubpathIterator( const VSubpath& list )
{
	m_list = const_cast<VSubpath*>( &list );
	m_current = m_list->m_first;

	if( !m_list->m_iteratorList )
		m_list->m_iteratorList = new VSubpathIteratorList();

	m_list->m_iteratorList->add( this );
}

VSubpathIterator::VSubpathIterator( const VSubpathIterator& itr )
{
	m_list = itr.m_list;
	m_current = itr.m_current;

	if( m_list )
		m_list->m_iteratorList->add( this );
}

VSubpathIterator::~VSubpathIterator()
{
	if( m_list )
		m_list->m_iteratorList->remove( this );
}

VSubpathIterator&
VSubpathIterator::operator=( const VSubpathIterator& itr )
{
	if( m_list )
		m_list->m_iteratorList->remove( this );

	m_list = itr.m_list;
	m_current = itr.m_current;

	if( m_list )
		m_list->m_iteratorList->add( this );

	return *this;
}

VSegment*
VSubpathIterator::current() const
{
	// If m_current points to a deleted segment, find the next not
	// deleted segment.
	if(
		m_current &&
		m_current->state() == VSegment::deleted )
	{
		return m_current->next();
	}

	return m_current;
}

VSegment*
VSubpathIterator::operator()()
{
	if( VSegment* const old = current() )
	{
		m_current = current()->next();
		return old;
	}

	return 0L;
}

VSegment*
VSubpathIterator::operator++()
{
	if( current() )
		return m_current = current()->next();

	return 0L;
}

VSegment*
VSubpathIterator::operator+=( uint i )
{
	while( current() && i-- )
		m_current = current()->next();

	return current();
}

VSegment*
VSubpathIterator::operator--()
{
	if( current() )
		return m_current = current()->prev();

	return 0L;
}

VSegment*
VSubpathIterator::operator-=( uint i )
{
	while( current() && i-- )
		m_current = current()->prev();

	return current();
}