gr_basic.cpp now clips filled polygons,using the Sutherland and Hodgman algo...

gr_basic.cpp now clips filled polygons,using the Sutherland and Hodgman algo to clip the poly against a rectangle
Filled polygons are now correctly displayed under Linux(i hope)

CHANGELOG.txt

@@ -5,6 +5,18 @@ Started 2007-June-11
 Please add newer entries at the top, list the date and your name with
 email address.
 
+2009-Feb-17 UPDATE Jean-Pierre Charras <jean-pierre.charras@inpg.fr>
+================================================================================
+++gr_basic.cpp
+    Added: Function ClipAndDrawFilledPoly()
+        Used to clip a polygon and display it as Filled Polygon
+        uses the Sutherland and Hodgman algo to clip the given poly against a rectangle.
+        This rectangle is the drawing area
+        this is useful under Linux (2009) because filled polygons are incorrectly drawn
+        if they have too large coordinates (seems due to integer overflows in calculations)
+        Could be removed in some years, if become unnecesary.
+
+
 2009-Feb-17 UPDATE Dick Hollenbeck <dick@softplc.com>
 ================================================================================
 ++pcbnew

common/gr_basic.cpp

@@ -31,6 +31,12 @@
  * and remember users can have old versions with bugs
  */
 
+#define USE_CLIP_FILLED_POLYGONS
+
+#ifdef USE_CLIP_FILLED_POLYGONS
+void ClipAndDrawFilledPoly( EDA_Rect * ClipBox, wxDC * DC, wxPoint Points[], int n );
+#endif
+
 /* global variables */
 extern BASE_SCREEN* ActiveScreen;
 
@@ -74,10 +80,12 @@ static inline int USCALE( us arg, us num, us den )
 }
 
 
-static int inline ZoomValue( int val ) {
+static int inline ZoomValue( int val )
+{
     return ActiveScreen->Scale( val );
 }
 
+
 /****************************************/
 /* External reference for the mappings. */
 /****************************************/
@@ -355,11 +363,13 @@ bool GetGRForceBlackPenState( void )
 void GRSetDrawMode( wxDC* DC, int draw_mode )
 {
     if( draw_mode & GR_OR )
-#if defined (__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
+#if defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
+
 
         DC->SetLogicalFunction( wxCOPY );
 #else
 
+
         DC->SetLogicalFunction( wxOR );
 #endif
     else if( draw_mode & GR_XOR )
@@ -877,7 +887,16 @@ static void GRSPoly( EDA_Rect* ClipBox, wxDC* DC, int n, wxPoint Points[], bool
     if( Fill && ( n > 2 ) )
     {
         GRSetBrush( DC, BgColor, FILLED );
-        DC->DrawPolygon( n, Points );
+
+
+        /* clip before send the filled polygon to wxDC, because under linux (GTK?)
+         *  polygonsl having large coordinates are incorrectly drawn
+         */
+#ifdef USE_CLIP_FILLED_POLYGONS
+        ClipAndDrawFilledPoly( ClipBox, DC, Points, n );
+#else
+         DC->DrawPolygon( n, Points ); //does not work very well under linux
+#endif
     }
     else
     {
@@ -1531,3 +1550,41 @@ void GRSetTextBgColor( wxDC* DC, wxFont*, int Color )
                                ColorRefs[Color].m_Blue )
                            );
 }
+
+#ifdef USE_CLIP_FILLED_POLYGONS
+
+/** Function ClipAndDrawFilledPoly
+ *  Used to clip a polygon and draw it as Filled Polygon
+ *  uses the Sutherland and Hodgman algo to clip the given poly against a rectangle.
+ *  This rectangle is the drawing area
+ *  this is useful under Linux (2009) because filled polygons are incorrectly drawn
+ *  if they have too large coordinates (seems due to integer overflows in calculations)
+ *  Could be removed in some years, if become unnecesary.
+ */
+#include "SutherlandHodgmanClipPoly.h"
+void ClipAndDrawFilledPoly( EDA_Rect* aClipBox, wxDC* aDC, wxPoint aPoints[], int n )
+{
+    static vector<wxPoint> clippedPolygon;
+    static pointVector     inputPolygon, outputPolygon;
+
+    inputPolygon.clear();
+    outputPolygon.clear();
+    clippedPolygon.clear();
+    for( int ii = 0; ii < n; ii++ )
+        inputPolygon.push_back( PointF( (REAL)aPoints[ii].x, (REAL)aPoints[ii].y ) );
+
+    RectF             window( (REAL) aClipBox->GetX(), (REAL) aClipBox->GetY(),
+                             (REAL) aClipBox->GetWidth(), (REAL) aClipBox->GetHeight() );
+
+    SutherlandHodgman sh( window );
+    sh.Clip( inputPolygon, outputPolygon );
+
+    for( cpointIterator cit = outputPolygon.begin(); cit != outputPolygon.end(); ++cit )
+    {
+        clippedPolygon.push_back( wxPoint( (int)round( cit->X ), (int)round( cit->Y ) ) );
+    }
+
+    if ( clippedPolygon.size() )
+        aDC->DrawPolygon( clippedPolygon.size(), &clippedPolygon[0] );
+}
+#endif

common/makefile.gtk

@@ -13,7 +13,7 @@ include makefile.include
 -include *.d
 
 # specfic Compiler flags and options
-CPPFLAGS += $(EXTRACPPFLAGS) -I./ -I../include -I$(BOOST)
+CPPFLAGS += $(EXTRACPPFLAGS) -I./ -I../include
 EDACPPFLAGS = $(CPPFLAGS)
 
 

common/makefile.include

-EXTRACPPFLAGS += -I$(SYSINCLUDE) -I./ -Ibitmaps -I../include
+EXTRACPPFLAGS += -I$(SYSINCLUDE) -I./ -Ibitmaps -I../include -I../polygon
 
 COMMON = ../include/colors.h
 

libs.linux

@@ -87,6 +87,8 @@ ifdef USE_MATCH_LAYER
 CPPFLAGS += -DUSE_MATCH_LAYER
 endif
 
+CPPFLAGS += -I $(BOOST_LIB)
+
 ifdef KICAD_PYTHON
 PYTHON_VERSION=2.5
 PYLIBS= -L/usr/lib
@@ -100,7 +102,7 @@ endif
 MESALIBSPATH = /usr/local/lib
 
 # Boost headers     (location of boost/)
-BOOST = ../
+BOOST_LIB = ../
 
 #for static link: add wx gl lib
 LIBVERSION=`wx-config --release`

libs.win

@@ -29,7 +29,7 @@ endif
 endif
 LIBVERSION = 2.8
 
-BOOST_PATH=/f/boost/boost
+BOOST_LIB=/f/boost/boost
 
 
 # You must comment or uncomment this line to disable/enable python support
@@ -45,7 +45,7 @@ ALL_LDFLAGS = -s #-v
 FINAL = 1
 endif
 
-CPPFLAGS += -I $(BOOST_PATH)
+CPPFLAGS += -I $(BOOST_LIB)
 
 ALL_CPPFLAGS = `$(WXWIN)/wx-config --cppflags` $(CPPFLAGS)
 EDACPPFLAGS = $(ALL_CPPFLAGS) $(ALL_CXXFLAGS) $(EXTRACPPFLAGS)

pcbnew/makefile.gtk

@@ -14,8 +14,8 @@ include makefile.include
 -include *.d
 
 # Additional compiler flags
-CPPFLAGS += $(EXTRACPPFLAGS) -I$(BOOST_LIB)
-EDACPPFLAGS = $(CPPFLAGS)  $(BOOST_LIB)
+CPPFLAGS += $(EXTRACPPFLAGS)
+EDACPPFLAGS = $(CPPFLAGS)
 
 
 $(TARGET): $(OBJECTS) makefile.gtk  makefile.include $(LIBVIEWER3D) $(EXTRALIBS) ../libs.linux

polygon/SutherlandHodgmanClipPoly.h

+/********************************************************************************
+*  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>
+
+using namespace std;
+#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 vector<PointF>                 pointVector;
+typedef vector<PointF>::iterator       pointIterator;
+typedef 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 )
+        { }
+        void HandleVertex( const PointF& pntCurrent )           // Function to handle one vertex
+        {
+            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 < less<REAL> >               BoundaryRight;
+    typedef BoundaryHor < greater_equal<REAL> >       BoundaryTop;
+    typedef BoundaryVert < greater_equal<REAL> >      BoundaryLeft;
+    typedef BoundaryHor < 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