/******************************************************************************** * Copyright (C) 2004 Sjaak Priester * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This file 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Tinter; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ********************************************************************************/ // SutherlandHodgman // Class to perform polygon clipping against an upright rectangular boundary window. // Implementation of Sutherland-Hodgman algorithm (1974). // // Version 1.0 (C) 2004, Sjaak Priester, Amsterdam. // mailto:sjaak@sjaakpriester.nl // http://www.sjaakpriester.nl #ifndef __SUTHERLAND_HODGMAN_H__ #define __SUTHERLAND_HODGMAN_H__ #include <vector> #include <functional> #ifndef _GDIPLUS_H // I designed this with GDI+ in mind. However, this particular code doesn't // use GDI+ at all, only some of it's variable types. // These definitions are substitutes for those of GDI+. typedef double REAL; class PointF { public: REAL X; REAL Y; PointF() : X( 0 ) , Y( 0 ) { } PointF( const PointF& p ) : X( p.X ) , Y( p.Y ) { } PointF( REAL x, REAL y ) : X( x ) , Y( y ) { } PointF operator+( const PointF& p ) const { return PointF( X + p.X, Y + p.Y ); } PointF operator-( const PointF& p ) const { return PointF( X - p.X, Y - p.Y ); } bool Equals( const PointF& p ) { return (X == p.X) && (Y == p.Y); } }; class RectF { public: REAL X; REAL Y; REAL Width; REAL Height; RectF() { X = 0, Y = 0, Height = 0, Width = 0; } RectF( const RectF& r ) { X = r.X; Y = r.Y; Height = r.Height, Width = r.Width; } RectF( REAL x, REAL y, REAL w, REAL h ) : X( x ), Y( y ),Width( w ), Height( h ) { } REAL GetLeft() const { return X; } REAL GetTop() const { return Y; } REAL GetRight() const { return X + Width; } REAL GetBottom() const { return Y + Height; } }; #endif // _GDIPLUS_H typedef std::vector<PointF> pointVector; typedef std::vector<PointF>::iterator pointIterator; typedef std::vector<PointF>::const_iterator cpointIterator; class SutherlandHodgman { public: // Constructor. Parameter is the boundary rectangle. // SutherlandHodgman expects a 'normalized' boundary rectangle, meaning // that boundaries.GetRight() > boundaries.GetLeft() and // boundaries.GetBottom() > boundaries.GetTop(). // In other words: boundary.Width > 0 and boundaries.Height > 0. // If this is violated, nothing will be output. SutherlandHodgman( RectF& boundaries ) : m_stageBottom( m_stageOut, boundaries.GetBottom() ) , /* Initialize each stage */ m_stageLeft( m_stageBottom, boundaries.GetLeft() ) , /* with its next stage and */ m_stageTop( m_stageLeft, boundaries.GetTop() ) , /* the boundary position. */ m_stageRight( m_stageTop, boundaries.GetRight() ) { } void Clip( pointVector& input, pointVector& clipped ) { clipped.clear(); m_stageOut.SetDestination( &clipped ); // Clip each input vertex. for( cpointIterator it = input.begin(); it != input.end(); ++it ) m_stageRight.HandleVertex( *it ); // Do the final step. m_stageRight.Finalize(); } private: // Implementation of a horizontal boundary (top or bottom). // Comp is a std::binary_function object, comparing its two parameters, f.i. std::less. template <class Comp> class BoundaryHor { public: BoundaryHor( REAL y ) : m_Y( y ) { } bool IsInside( const PointF& pnt ) const { return Comp ()( pnt.Y, m_Y ); } // return true if pnt.Y is at the inside of the boundary PointF Intersect( const PointF& p0, const PointF& p1 ) const // return intersection point of line p0...p1 with boundary { // assumes p0...p1 is not strictly horizontal PointF d = p1 - p0; REAL xslope = d.X / d.Y; PointF r; r.Y = m_Y; r.X = p0.X + xslope * (m_Y - p0.Y); return r; } private: REAL m_Y; }; // Implementation of a vertical boundary (left or right). template <class Comp> class BoundaryVert { public: BoundaryVert( REAL x ) : m_X( x ) { } bool IsInside( const PointF& pnt ) const { return Comp() ( pnt.X, m_X ); } PointF Intersect( const PointF& p0, const PointF& p1 ) const // assumes p0...p1 is not strictly vertical { PointF d = p1 - p0; REAL yslope = d.Y / d.X; PointF r; r.X = m_X; r.Y = p0.Y + yslope * (m_X - p0.X); return r; } private: REAL m_X; }; // This template class is the workhorse of the algorithm. It handles the clipping against one boundary. // Boundary is either BoundaryHor or BoundaryVert, Stage is the next ClipStage, or the output stage. template <class Boundary, class Stage> class ClipStage : private Boundary { public: ClipStage( Stage& nextStage, REAL position ) : Boundary( position ) , m_NextStage( nextStage ), m_bFirst( true ), m_bPreviousInside( false ) { } // Function to handle one vertex void HandleVertex( const PointF& pntCurrent ) { bool bCurrentInside = this->IsInside( pntCurrent ); // See if vertex is inside the boundary. if( m_bFirst ) // If this is the first vertex... { m_pntFirst = pntCurrent; // ... just remember it,... m_bFirst = false; } else // Common cases, not the first vertex. { if( bCurrentInside ) // If this vertex is inside... { if( !m_bPreviousInside ) // ... and the previous one was outside m_NextStage.HandleVertex( this->Intersect( m_pntPrevious, pntCurrent ) ); // ... first output the intersection point. m_NextStage.HandleVertex( pntCurrent ); // Output the current vertex. } else if( m_bPreviousInside ) // If this vertex is outside, and the previous one was inside... m_NextStage.HandleVertex( this->Intersect( m_pntPrevious, pntCurrent ) ); // ... output the intersection point. // If neither current vertex nor the previous one are inside, output nothing. } m_pntPrevious = pntCurrent; // Be prepared for next vertex. m_bPreviousInside = bCurrentInside; } void Finalize() { HandleVertex( m_pntFirst ); // Close the polygon. m_NextStage.Finalize(); // Delegate to the next stage. } private: Stage& m_NextStage; // the next stage bool m_bFirst; // true if no vertices have been handled PointF m_pntFirst; // the first vertex PointF m_pntPrevious; // the previous vertex bool m_bPreviousInside; // true if the previous vertex was inside the Boundary }; class OutputStage { public: OutputStage() : m_pDest( 0 ) { } void SetDestination( pointVector* pDest ) { m_pDest = pDest; } void HandleVertex( const PointF& pnt ) { m_pDest->push_back( pnt ); } // Append the vertex to the output container. void Finalize() { } // Do nothing. private: pointVector* m_pDest; }; // These typedefs define the four boundaries. In keeping up with the GDI/GDI+ interpretation of // rectangles, we include the left and top boundaries, but not the right and bottom boundaries. // In other words: a vertex on the left boundary is considered to be inside, but a vertex // on the right boundary is considered to be outside. typedef BoundaryVert<std::less<REAL> > BoundaryRight; typedef BoundaryHor<std::greater_equal<REAL> > BoundaryTop; typedef BoundaryVert<std::greater_equal<REAL> > BoundaryLeft; typedef BoundaryHor<std::less<REAL> > BoundaryBottom; // Next typedefs define the four stages. First template parameter is the boundary, // second template parameter is the next stage. typedef ClipStage<BoundaryBottom, OutputStage> ClipBottom; typedef ClipStage<BoundaryLeft, ClipBottom> ClipLeft; typedef ClipStage<BoundaryTop, ClipLeft> ClipTop; typedef ClipStage<BoundaryRight, ClipTop> ClipRight; // Our data members. OutputStage m_stageOut; ClipBottom m_stageBottom; ClipLeft m_stageLeft; ClipTop m_stageTop; ClipRight m_stageRight; }; #endif