haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed all dependencies on boost::polygon except for bitmap2component. Replaced almost all instances of CPOLYGONS_LIST with SHAPE_POLY_SET.

This commit is contained in:
Tomasz Wlostowski 2015-07-14 13:36:24 +02:00 committed by Maciej Suminski
parent c8f8256329
commit 41c753b05d
57 changed files with 1221 additions and 5025 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
3d-viewer/3d_canvas.h
View File

@ -49,7 +49,7 @@
class BOARD_DESIGN_SETTINGS; class BOARD_DESIGN_SETTINGS;
class EDA_3D_FRAME; class EDA_3D_FRAME;
class CPOLYGONS_LIST; class SHAPE_POLY_SET;
class REPORTER; class REPORTER;
class VIA; class VIA;
@ -306,7 +306,7 @@ private:
* Used only to draw pads outlines on silkscreen layers. * Used only to draw pads outlines on silkscreen layers.
*/ */
void buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad, void buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad,
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aWidth, int aWidth,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ); double aCorrectionFactor );

15
3d-viewer/3d_draw.cpp
View File

@ -637,9 +637,7 @@ void EDA_3D_CANVAS::buildBoard3DAuxLayers( REPORTER* aErrorMessages, REPORTER* a
double correctionFactor = 1.0 / cos( M_PI / (segcountforcircle * 2) ); double correctionFactor = 1.0 / cos( M_PI / (segcountforcircle * 2) );
BOARD* pcb = GetBoard(); BOARD* pcb = GetBoard();
CPOLYGONS_LIST bufferPolys; SHAPE_POLY_SET bufferPolys;
bufferPolys.reserve( 5000 ); // Reserve for items not on board
static const LAYER_ID sequence[] = { static const LAYER_ID sequence[] = {
Dwgs_User, Dwgs_User,
@ -701,12 +699,10 @@ void EDA_3D_CANVAS::buildBoard3DAuxLayers( REPORTER* aErrorMessages, REPORTER* a
// bufferPolys contains polygons to merge. Many overlaps . // bufferPolys contains polygons to merge. Many overlaps .
// Calculate merged polygons and remove pads and vias holes // Calculate merged polygons and remove pads and vias holes
if( bufferPolys.GetCornersCount() == 0 ) if( bufferPolys.IsEmpty() )
continue; continue;
KI_POLYGON_SET currLayerPolyset;
KI_POLYGON_SET polyset; bufferPolys.Fracture();
bufferPolys.ExportTo( polyset );
currLayerPolyset += polyset;
int thickness = GetPrm3DVisu().GetLayerObjectThicknessBIU( layer ); int thickness = GetPrm3DVisu().GetLayerObjectThicknessBIU( layer );
int zpos = GetPrm3DVisu().GetLayerZcoordBIU( layer ); int zpos = GetPrm3DVisu().GetLayerZcoordBIU( layer );
@ -719,9 +715,6 @@ void EDA_3D_CANVAS::buildBoard3DAuxLayers( REPORTER* aErrorMessages, REPORTER* a
else else
zpos -= thickness/2 ; zpos -= thickness/2 ;
bufferPolys.RemoveAllContours();
bufferPolys.ImportFrom( currLayerPolyset );
float zNormal = 1.0f; // When using thickness it will draw first the top and then botton (with z inverted) float zNormal = 1.0f; // When using thickness it will draw first the top and then botton (with z inverted)
// If we are not using thickness, then the znormal must face the layer direction // If we are not using thickness, then the znormal must face the layer direction

71
3d-viewer/3d_draw_basic_functions.cpp
View File

@ -62,7 +62,7 @@ void TransfertToGLlist( std::vector< S3D_VERTEX >& aVertices, double aBiuTo3DUni
* from Z position = aZpos to aZpos + aHeight * from Z position = aZpos to aZpos + aHeight
* Used to create the vertical sides of 3D horizontal shapes with thickness. * Used to create the vertical sides of 3D horizontal shapes with thickness.
*/ */
static void Draw3D_VerticalPolygonalCylinder( const CPOLYGONS_LIST& aPolysList, static void Draw3D_VerticalPolygonalCylinder( const SHAPE_POLY_SET& aPolysList,
int aHeight, int aZpos, int aHeight, int aZpos,
bool aInside, double aBiuTo3DUnits ) bool aInside, double aBiuTo3DUnits )
{ {
@ -87,30 +87,29 @@ static void Draw3D_VerticalPolygonalCylinder( const CPOLYGONS_LIST& aPolysList,
coords[3].z = coords[0].z; coords[3].z = coords[0].z;
// Draw the vertical polygonal side // Draw the vertical polygonal side
int startContour = 0; for( int ii = 0; ii < aPolysList.OutlineCount(); ii++ )
for( unsigned ii = 0; ii < aPolysList.GetCornersCount(); ii++ )
{ {
unsigned jj = ii + 1; const SHAPE_LINE_CHAIN& path = aPolysList.COutline( ii );
if( aPolysList.IsEndContour( ii ) || jj >= aPolysList.GetCornersCount() ) for( int jj = 0; jj < path.PointCount(); jj++ )
{ {
jj = startContour; const VECTOR2I& a = path.CPoint( jj );
startContour = ii + 1; const VECTOR2I& b = path.CPoint( jj + 1 );
}
// Build the 4 vertices of each GL_QUAD // Build the 4 vertices of each GL_QUAD
coords[0].x = aPolysList.GetX( ii ); coords[0].x = a.x;
coords[0].y = -aPolysList.GetY( ii ); coords[0].y = -a.y;
coords[1].x = coords[0].x; coords[1].x = coords[0].x;
coords[1].y = coords[0].y; // only z change coords[1].y = coords[0].y; // only z change
coords[2].x = aPolysList.GetX( jj ); coords[2].x = b.x;
coords[2].y = -aPolysList.GetY( jj ); coords[2].y = -b.y;
coords[3].x = coords[2].x; coords[3].x = coords[2].x;
coords[3].y = coords[2].y; // only z change coords[3].y = coords[2].y; // only z change
// Creates the GL_QUAD // Creates the GL_QUAD
TransfertToGLlist( coords, aBiuTo3DUnits ); TransfertToGLlist( coords, aBiuTo3DUnits );
} }
}
} }
@ -147,7 +146,7 @@ void SetGLTexture( GLuint text_id, float scale )
* The top side is located at aZpos + aThickness / 2 * The top side is located at aZpos + aThickness / 2
* The bottom side is located at aZpos - aThickness / 2 * The bottom side is located at aZpos - aThickness / 2
*/ */
void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList, void Draw3D_SolidHorizontalPolyPolygons( const SHAPE_POLY_SET& aPolysList,
int aZpos, int aThickness, double aBiuTo3DUnits, int aZpos, int aThickness, double aBiuTo3DUnits,
bool aUseTextures, bool aUseTextures,
float aNormal_Z_Orientation ) float aNormal_Z_Orientation )
@ -176,7 +175,7 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
glNormal3f( 0.0, 0.0, aNormal_Z_Orientation ); glNormal3f( 0.0, 0.0, aNormal_Z_Orientation );
// Draw solid areas contained in this list // Draw solid areas contained in this list
CPOLYGONS_LIST polylist = aPolysList; // temporary copy for gluTessVertex SHAPE_POLY_SET polylist = aPolysList; // temporary copy for gluTessVertex
int startContour; int startContour;
@ -184,7 +183,7 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
{ {
startContour = 1; startContour = 1;
for( unsigned ii = 0; ii < polylist.GetCornersCount(); ii++ ) for ( SHAPE_POLY_SET::ITERATOR ii = polylist.Iterate(); ii; ++ii )
{ {
if( startContour == 1 ) if( startContour == 1 )
{ {
@ -193,16 +192,16 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
startContour = 0; startContour = 0;
} }
v_data[0] = polylist.GetX( ii ) * aBiuTo3DUnits; v_data[0] = ii->x * aBiuTo3DUnits;
v_data[1] = -polylist.GetY( ii ) * aBiuTo3DUnits; v_data[1] = -ii->y * aBiuTo3DUnits;
// gluTessVertex store pointers on data, not data, so do not store // gluTessVertex store pointers on data, not data, so do not store
// different corners values in a temporary variable // different corners values in a temporary variable
// but send pointer on each CPolyPt value in polylist // but send pointer on each CPolyPt value in polylist
// before calling gluDeleteTess // before calling gluDeleteTess
gluTessVertex( tess, v_data, &polylist[ii] ); gluTessVertex( tess, v_data, &ii.Get() );
if( polylist.IsEndContour( ii ) ) if( ii.IsEndContour() )
{ {
gluTessEndContour( tess ); gluTessEndContour( tess );
gluTessEndPolygon( tess ); gluTessEndPolygon( tess );
@ -242,14 +241,15 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
* The first polygon is the main polygon, others are holes * The first polygon is the main polygon, others are holes
* See Draw3D_SolidHorizontalPolyPolygons for more info * See Draw3D_SolidHorizontalPolyPolygons for more info
*/ */
void Draw3D_SolidHorizontalPolygonWithHoles( const CPOLYGONS_LIST& aPolysList, void Draw3D_SolidHorizontalPolygonWithHoles( const SHAPE_POLY_SET& aPolysList,
int aZpos, int aThickness, int aZpos, int aThickness,
double aBiuTo3DUnits, bool aUseTextures, double aBiuTo3DUnits, bool aUseTextures,
float aNormal_Z_Orientation ) float aNormal_Z_Orientation )
{ {
CPOLYGONS_LIST polygon; SHAPE_POLY_SET polygon( aPolysList );
polygon.Fracture();
ConvertPolysListWithHolesToOnePolygon( aPolysList, polygon );
Draw3D_SolidHorizontalPolyPolygons( polygon, aZpos, aThickness, aBiuTo3DUnits, aUseTextures, Draw3D_SolidHorizontalPolyPolygons( polygon, aZpos, aThickness, aBiuTo3DUnits, aUseTextures,
aNormal_Z_Orientation ); aNormal_Z_Orientation );
} }
@ -265,7 +265,7 @@ void Draw3D_ZaxisCylinder( wxPoint aCenterPos, int aRadius,
int aZpos, double aBiuTo3DUnits ) int aZpos, double aBiuTo3DUnits )
{ {
const int slice = SEGM_PER_CIRCLE; const int slice = SEGM_PER_CIRCLE;
CPOLYGONS_LIST outer_cornerBuffer; SHAPE_POLY_SET outer_cornerBuffer;
TransformCircleToPolygon( outer_cornerBuffer, aCenterPos, TransformCircleToPolygon( outer_cornerBuffer, aCenterPos,
aRadius + (aThickness / 2), slice ); aRadius + (aThickness / 2), slice );
@ -273,7 +273,7 @@ void Draw3D_ZaxisCylinder( wxPoint aCenterPos, int aRadius,
std::vector<S3D_VERTEX> coords; std::vector<S3D_VERTEX> coords;
coords.resize( 4 ); coords.resize( 4 );
CPOLYGONS_LIST inner_cornerBuffer; SHAPE_POLY_SET inner_cornerBuffer;
if( aThickness ) // build the the vertical inner polygon (hole) if( aThickness ) // build the the vertical inner polygon (hole)
TransformCircleToPolygon( inner_cornerBuffer, aCenterPos, TransformCircleToPolygon( inner_cornerBuffer, aCenterPos,
aRadius - (aThickness / 2), slice ); aRadius - (aThickness / 2), slice );
@ -294,10 +294,11 @@ void Draw3D_ZaxisCylinder( wxPoint aCenterPos, int aRadius,
if( aThickness ) if( aThickness )
{ {
// draw top (front) and bottom (back) horizontal sides (rings) // draw top (front) and bottom (back) horizontal sides (rings)
outer_cornerBuffer.Append( inner_cornerBuffer ); outer_cornerBuffer.AddHole( inner_cornerBuffer.COutline( 0 ) );
CPOLYGONS_LIST polygon; SHAPE_POLY_SET polygon = outer_cornerBuffer;
polygon.Fracture();
ConvertPolysListWithHolesToOnePolygon( outer_cornerBuffer, polygon );
// draw top (front) horizontal ring // draw top (front) horizontal ring
Draw3D_SolidHorizontalPolyPolygons( polygon, aZpos + aHeight, 0, aBiuTo3DUnits, false, Draw3D_SolidHorizontalPolyPolygons( polygon, aZpos + aHeight, 0, aBiuTo3DUnits, false,
1.0f ); 1.0f );
@ -326,7 +327,7 @@ void Draw3D_ZaxisOblongCylinder( wxPoint aAxis1Pos, wxPoint aAxis2Pos,
const int slice = SEGM_PER_CIRCLE; const int slice = SEGM_PER_CIRCLE;
// Build the points to approximate oblong cylinder by segments // Build the points to approximate oblong cylinder by segments
CPOLYGONS_LIST outer_cornerBuffer; SHAPE_POLY_SET outer_cornerBuffer;
int segm_width = (aRadius * 2) + aThickness; int segm_width = (aRadius * 2) + aThickness;
TransformRoundedEndsSegmentToPolygon( outer_cornerBuffer, aAxis1Pos, TransformRoundedEndsSegmentToPolygon( outer_cornerBuffer, aAxis1Pos,
@ -339,7 +340,7 @@ void Draw3D_ZaxisOblongCylinder( wxPoint aAxis1Pos, wxPoint aAxis2Pos,
if( aThickness ) if( aThickness )
{ {
CPOLYGONS_LIST inner_cornerBuffer; SHAPE_POLY_SET inner_cornerBuffer;
segm_width = aRadius * 2; segm_width = aRadius * 2;
TransformRoundedEndsSegmentToPolygon( inner_cornerBuffer, aAxis1Pos, TransformRoundedEndsSegmentToPolygon( inner_cornerBuffer, aAxis1Pos,
aAxis2Pos, slice, segm_width ); aAxis2Pos, slice, segm_width );
@ -351,10 +352,10 @@ void Draw3D_ZaxisOblongCylinder( wxPoint aAxis1Pos, wxPoint aAxis2Pos,
// Build the horizontal full polygon shape // Build the horizontal full polygon shape
// (outer polygon shape - inner polygon shape) // (outer polygon shape - inner polygon shape)
outer_cornerBuffer.Append( inner_cornerBuffer ); outer_cornerBuffer.AddHole( inner_cornerBuffer.COutline( 0 ) );
CPOLYGONS_LIST polygon; SHAPE_POLY_SET polygon( outer_cornerBuffer );
ConvertPolysListWithHolesToOnePolygon( outer_cornerBuffer, polygon ); polygon.Fracture();
// draw top (front) horizontal side (ring) // draw top (front) horizontal side (ring)
Draw3D_SolidHorizontalPolyPolygons( polygon, aZpos + aHeight, 0, aBiuTo3DUnits, false, Draw3D_SolidHorizontalPolyPolygons( polygon, aZpos + aHeight, 0, aBiuTo3DUnits, false,
@ -379,7 +380,7 @@ void Draw3D_ZaxisOblongCylinder( wxPoint aAxis1Pos, wxPoint aAxis2Pos,
void Draw3D_SolidSegment( const wxPoint& aStart, const wxPoint& aEnd, void Draw3D_SolidSegment( const wxPoint& aStart, const wxPoint& aEnd,
int aWidth, int aThickness, int aZpos, double aBiuTo3DUnits ) int aWidth, int aThickness, int aZpos, double aBiuTo3DUnits )
{ {
CPOLYGONS_LIST cornerBuffer; SHAPE_POLY_SET cornerBuffer;
const int slice = SEGM_PER_CIRCLE; const int slice = SEGM_PER_CIRCLE;
TransformRoundedEndsSegmentToPolygon( cornerBuffer, aStart, aEnd, slice, aWidth ); TransformRoundedEndsSegmentToPolygon( cornerBuffer, aStart, aEnd, slice, aWidth );
@ -394,7 +395,7 @@ void Draw3D_ArcSegment( const wxPoint& aCenterPos, const wxPoint& aStartPoint,
{ {
const int slice = SEGM_PER_CIRCLE; const int slice = SEGM_PER_CIRCLE;
CPOLYGONS_LIST cornerBuffer; SHAPE_POLY_SET cornerBuffer;
TransformArcToPolygon( cornerBuffer, aCenterPos, aStartPoint, aArcAngle, TransformArcToPolygon( cornerBuffer, aCenterPos, aStartPoint, aArcAngle,
slice, aWidth ); slice, aWidth );
@ -421,7 +422,7 @@ void CALLBACK tessEndCB()
void CALLBACK tessCPolyPt2Vertex( const GLvoid* data ) void CALLBACK tessCPolyPt2Vertex( const GLvoid* data )
{ {
// cast back to double type // cast back to double type
const CPolyPt* ptr = (const CPolyPt*) data; const VECTOR2I* ptr = (const VECTOR2I*) data;
if( s_useTextures ) if( s_useTextures )
{ {

4
3d-viewer/3d_draw_basic_functions.h
View File

@ -43,7 +43,7 @@
* The top side is located at aZpos + aThickness / 2 * The top side is located at aZpos + aThickness / 2
* The bottom side is located at aZpos - aThickness / 2 * The bottom side is located at aZpos - aThickness / 2
*/ */
void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList, void Draw3D_SolidHorizontalPolyPolygons( const SHAPE_POLY_SET& aPolysList,
int aZpos, int aThickness, double aBiuTo3DUnits, int aZpos, int aThickness, double aBiuTo3DUnits,
bool aUseTextures, bool aUseTextures,
float aNormal_Z_Orientation ); float aNormal_Z_Orientation );
@ -61,7 +61,7 @@ void Draw3D_SolidHorizontalPolyPolygons( const CPOLYGONS_LIST& aPolysList,
* The top side is located at aZpos + aThickness / 2 * The top side is located at aZpos + aThickness / 2
* The bottom side is located at aZpos - aThickness / 2 * The bottom side is located at aZpos - aThickness / 2
*/ */
void Draw3D_SolidHorizontalPolygonWithHoles( const CPOLYGONS_LIST& aPolysList, void Draw3D_SolidHorizontalPolygonWithHoles( const SHAPE_POLY_SET& aPolysList,
int aZpos, int aThickness, double aBiuTo3DUnits, int aZpos, int aThickness, double aBiuTo3DUnits,
bool aUseTextures, bool aUseTextures,
float aNormal_Z_Orientation ); float aNormal_Z_Orientation );

142
3d-viewer/3d_draw_board_body.cpp
View File

@ -57,6 +57,8 @@
#include <trackball.h> #include <trackball.h>
#include <3d_draw_basic_functions.h> #include <3d_draw_basic_functions.h>
#include <geometry/shape_poly_set.h> #include <geometry/shape_poly_set.h>
#include <geometry/shape_file_io.h>
#include <CImage.h> #include <CImage.h>
#include <reporter.h> #include <reporter.h>
@ -68,6 +70,7 @@
*/ */
GLfloat Get3DLayer_Z_Orientation( LAYER_NUM aLayer ); GLfloat Get3DLayer_Z_Orientation( LAYER_NUM aLayer );
#if 0
// FIX ME: these 2 functions are fully duplicate of the same 2 functions in // FIX ME: these 2 functions are fully duplicate of the same 2 functions in
// pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp // pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp
@ -88,7 +91,7 @@ static const SHAPE_POLY_SET convertPolyListToPolySet(const CPOLYGONS_LIST& aList
while( ic < corners_count ) while( ic < corners_count )
{ {
rv.AppendVertex( aList.GetX(ic), aList.GetY(ic) ); rv.Append( aList.GetX(ic), aList.GetY(ic) );
if( aList.IsEndContour( ic ) ) if( aList.IsEndContour( ic ) )
break; break;
@ -128,6 +131,7 @@ static const CPOLYGONS_LIST convertPolySetToPolyList(const SHAPE_POLY_SET& aPoly
return list; return list;
} }
#endif
void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList, void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList,
REPORTER* aErrorMessages, REPORTER* aActivity ) REPORTER* aErrorMessages, REPORTER* aActivity )
@ -156,14 +160,12 @@ void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList,
// a fine representation // a fine representation
double correctionFactorLQ = 1.0 / cos( M_PI / (segcountLowQuality * 2.0) ); double correctionFactorLQ = 1.0 / cos( M_PI / (segcountLowQuality * 2.0) );
CPOLYGONS_LIST bufferPolys; SHAPE_POLY_SET bufferPolys;
bufferPolys.reserve( 500000 ); // Reserve for large board: tracks mainly SHAPE_POLY_SET bufferPcbOutlines; // stores the board main outlines
SHAPE_POLY_SET bufferZonesPolys;
SHAPE_POLY_SET currLayerHoles, allLayerHoles; // Contains holes for the current layer
// + zones when holes are removed from zones // + zones when holes are removed from zones
CPOLYGONS_LIST bufferPcbOutlines; // stores the board main outlines
CPOLYGONS_LIST allLayerHoles; // Contains through holes, calculated only once
allLayerHoles.reserve( 20000 );
// Build a polygon from edge cut items // Build a polygon from edge cut items
wxString msg; wxString msg;
@ -179,11 +181,6 @@ void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList,
} }
} }
CPOLYGONS_LIST bufferZonesPolys;
bufferZonesPolys.reserve( 300000 ); // Reserve for large board ( copper zones mainly )
// when holes are not removed from zones
CPOLYGONS_LIST currLayerHoles; // Contains holes for the current layer
bool throughHolesListBuilt = false; // flag to build the through hole polygon list only once bool throughHolesListBuilt = false; // flag to build the through hole polygon list only once
LSET cu_set = LSET::AllCuMask( GetPrm3DVisu().m_CopperLayersCount ); LSET cu_set = LSET::AllCuMask( GetPrm3DVisu().m_CopperLayersCount );
@ -351,47 +348,35 @@ void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList,
// bufferPolys contains polygons to merge. Many overlaps . // bufferPolys contains polygons to merge. Many overlaps .
// Calculate merged polygons // Calculate merged polygons
if( bufferPolys.GetCornersCount() == 0 ) if( bufferPolys.IsEmpty() )
continue; continue;
#if 0 std::auto_ptr<SHAPE_FILE_IO> dumper( new SHAPE_FILE_IO( "poly_dump.txt", true ) );
// Set to 1 to use boost::polygon to subtract holes to copper areas
// (due to bugs in boost::polygon, this is deprecated and Clipper is used instead
KI_POLYGON_SET currLayerPolyset;
KI_POLYGON_SET polysetHoles;
// Add polygons, without holes
bufferPolys.ExportTo( currLayerPolyset );
// Add through holes (created only once) in current polygon holes list
currLayerHoles.Append( allLayerHoles );
if( currLayerHoles.GetCornersCount() > 0 )
currLayerHoles.ExportTo( polysetHoles );
// Merge polygons, and remove holes
currLayerPolyset -= polysetHoles;
bufferPolys.RemoveAllContours();
bufferPolys.ImportFrom( currLayerPolyset );
#else
// Use Clipper lib to subtract holes to copper areas // Use Clipper lib to subtract holes to copper areas
SHAPE_POLY_SET solidAreas = convertPolyListToPolySet( bufferPolys );
solidAreas.Simplify(); dumper->BeginGroup( "clipper-zone" );
dumper->Write( &bufferPolys, "pre-simplify" );
bufferPolys.Simplify();
dumper->Write( &bufferPolys, "post-simplify" );
currLayerHoles.Simplify();
allLayerHoles.Simplify();
//dumper->Write(&bufferPolys, "pre-sub");
//dumper->Write(&allLayerHoles, "holes");
// Add through holes (created only once) in current polygon holes list // Add through holes (created only once) in current polygon holes list
currLayerHoles.Append( allLayerHoles ); //bufferPolys.BooleanSubtract( currLayerHoles );
if( currLayerHoles.GetCornersCount() > 0 ) //bufferPolys.Simplify();
{ bufferPolys.BooleanSubtract( allLayerHoles );
SHAPE_POLY_SET holes = convertPolyListToPolySet( currLayerHoles );
holes.Simplify(); //dumper->Write(&bufferPolys, "post-sub");
solidAreas.Subtract ( holes ); dumper->EndGroup();
}
SHAPE_POLY_SET fractured = solidAreas; bufferPolys.Fracture();
fractured.Fracture();
bufferPolys.RemoveAllContours();
bufferPolys = convertPolySetToPolyList( fractured );
#endif
int thickness = GetPrm3DVisu().GetLayerObjectThicknessBIU( layer ); int thickness = GetPrm3DVisu().GetLayerObjectThicknessBIU( layer );
int zpos = GetPrm3DVisu().GetLayerZcoordBIU( layer ); int zpos = GetPrm3DVisu().GetLayerZcoordBIU( layer );
@ -421,7 +406,7 @@ void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList,
// If holes are not removed from copper zones (for calculation time reasons, // If holes are not removed from copper zones (for calculation time reasons,
// the zone polygons are stored in bufferZonesPolys and have to be drawn now: // the zone polygons are stored in bufferZonesPolys and have to be drawn now:
if( bufferZonesPolys.GetCornersCount() ) if( !bufferZonesPolys.IsEmpty() )
{ {
Draw3D_SolidHorizontalPolyPolygons( bufferZonesPolys, zpos, thickness, Draw3D_SolidHorizontalPolyPolygons( bufferZonesPolys, zpos, thickness,
GetPrm3DVisu().m_BiuTo3Dunits, useTextures, GetPrm3DVisu().m_BiuTo3Dunits, useTextures,
@ -490,22 +475,10 @@ void EDA_3D_CANVAS::buildBoard3DView( GLuint aBoardList, GLuint aBodyOnlyList,
zpos += (copper_thickness + epsilon) / 2.0f; zpos += (copper_thickness + epsilon) / 2.0f;
board_thickness -= copper_thickness + epsilon; board_thickness -= copper_thickness + epsilon;
KI_POLYGON_SET currLayerPolyset; bufferPcbOutlines.BooleanSubtract( allLayerHoles );
KI_POLYGON_SET polysetHoles; bufferPcbOutlines.Fracture();
// Add polygons, without holes if( !bufferPcbOutlines.IsEmpty() )
bufferPcbOutlines.ExportTo( currLayerPolyset );
// Build holes list
allLayerHoles.ExportTo( polysetHoles );
// remove holes
currLayerPolyset -= polysetHoles;
bufferPcbOutlines.RemoveAllContours();
bufferPcbOutlines.ImportFrom( currLayerPolyset );
if( bufferPcbOutlines.GetCornersCount() )
{ {
Draw3D_SolidHorizontalPolyPolygons( bufferPcbOutlines, zpos + board_thickness / 2.0, Draw3D_SolidHorizontalPolyPolygons( bufferPcbOutlines, zpos + board_thickness / 2.0,
board_thickness, GetPrm3DVisu().m_BiuTo3Dunits, useTextures, board_thickness, GetPrm3DVisu().m_BiuTo3Dunits, useTextures,
@ -531,12 +504,9 @@ void EDA_3D_CANVAS::buildTechLayers3DView( REPORTER* aErrorMessages, REPORTER* a
double correctionFactorLQ = 1.0 / cos( M_PI / (segcountLowQuality * 2) ); double correctionFactorLQ = 1.0 / cos( M_PI / (segcountLowQuality * 2) );
CPOLYGONS_LIST bufferPolys; SHAPE_POLY_SET bufferPolys;
bufferPolys.reserve( 100000 ); // Reserve for large board SHAPE_POLY_SET allLayerHoles; // Contains through holes, calculated only once
CPOLYGONS_LIST allLayerHoles; // Contains through holes, calculated only once SHAPE_POLY_SET bufferPcbOutlines; // stores the board main outlines
allLayerHoles.reserve( 20000 );
CPOLYGONS_LIST bufferPcbOutlines; // stores the board main outlines
// Build a polygon from edge cut items // Build a polygon from edge cut items
wxString msg; wxString msg;
@ -581,9 +551,6 @@ void EDA_3D_CANVAS::buildTechLayers3DView( REPORTER* aErrorMessages, REPORTER* a
// draw graphic items, on technical layers // draw graphic items, on technical layers
KI_POLYGON_SET brdpolysetHoles;
allLayerHoles.ExportTo( brdpolysetHoles );
static const LAYER_ID teckLayerList[] = { static const LAYER_ID teckLayerList[] = {
B_Adhes, B_Adhes,
F_Adhes, F_Adhes,
@ -675,33 +642,34 @@ void EDA_3D_CANVAS::buildTechLayers3DView( REPORTER* aErrorMessages, REPORTER* a
// bufferPolys contains polygons to merge. Many overlaps . // bufferPolys contains polygons to merge. Many overlaps .
// Calculate merged polygons and remove pads and vias holes // Calculate merged polygons and remove pads and vias holes
if( bufferPolys.GetCornersCount() == 0 ) if( bufferPolys.IsEmpty() )
continue; continue;
KI_POLYGON_SET currLayerPolyset;
KI_POLYGON_SET polyset; allLayerHoles.Simplify();
// Solder mask layers are "negative" layers. // Solder mask layers are "negative" layers.
// Shapes should be removed from the full board area. // Shapes should be removed from the full board area.
if( layer == B_Mask || layer == F_Mask ) if( layer == B_Mask || layer == F_Mask )
{ {
bufferPcbOutlines.ExportTo( currLayerPolyset ); SHAPE_POLY_SET cuts = bufferPolys;
bufferPolys.Append( allLayerHoles ); bufferPolys = bufferPcbOutlines;
bufferPolys.ExportTo( polyset );
currLayerPolyset -= polyset; cuts.Append(allLayerHoles);
cuts.Simplify();
bufferPolys.BooleanSubtract( cuts );
} }
// Remove holes from Solder paste layers and siklscreen // Remove holes from Solder paste layers and siklscreen
else if( layer == B_Paste || layer == F_Paste else if( layer == B_Paste || layer == F_Paste
|| layer == B_SilkS || layer == F_SilkS ) || layer == B_SilkS || layer == F_SilkS )
{ {
bufferPolys.ExportTo( currLayerPolyset );
currLayerPolyset -= brdpolysetHoles; bufferPolys.BooleanSubtract( allLayerHoles );
}
else // usuall layers, merge polys built from each item shape:
{
bufferPolys.ExportTo( polyset );
currLayerPolyset += polyset;
} }
bufferPolys.Fracture();
int thickness = 0; int thickness = 0;
if( layer != B_Mask && layer != F_Mask ) if( layer != B_Mask && layer != F_Mask )
@ -728,8 +696,6 @@ void EDA_3D_CANVAS::buildTechLayers3DView( REPORTER* aErrorMessages, REPORTER* a
zpos -= thickness/2 ; zpos -= thickness/2 ;
} }
bufferPolys.RemoveAllContours();
bufferPolys.ImportFrom( currLayerPolyset );
float zNormal = 1.0f; // When using thickness it will draw first the top and then botton (with z inverted) float zNormal = 1.0f; // When using thickness it will draw first the top and then botton (with z inverted)

19
3d-viewer/3d_draw_helper_functions.cpp
View File

@ -358,7 +358,7 @@ void EDA_3D_CANVAS::draw3DPadHole( const D_PAD* aPad )
return; return;
// Store here the points to approximate hole by segments // Store here the points to approximate hole by segments
CPOLYGONS_LIST holecornersBuffer; SHAPE_POLY_SET holecornersBuffer;
int thickness = GetPrm3DVisu().GetCopperThicknessBIU(); int thickness = GetPrm3DVisu().GetCopperThicknessBIU();
int height = GetPrm3DVisu().GetLayerZcoordBIU( F_Cu ) - int height = GetPrm3DVisu().GetLayerZcoordBIU( F_Cu ) -
GetPrm3DVisu().GetLayerZcoordBIU( B_Cu ); GetPrm3DVisu().GetLayerZcoordBIU( B_Cu );
@ -436,7 +436,7 @@ void EDA_3D_CANVAS::draw3DViaHole( const VIA* aVia )
* Used only to draw pads outlines on silkscreen layers. * Used only to draw pads outlines on silkscreen layers.
*/ */
void EDA_3D_CANVAS::buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad, void EDA_3D_CANVAS::buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad,
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aWidth, int aWidth,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) double aCorrectionFactor )
@ -449,17 +449,22 @@ void EDA_3D_CANVAS::buildPadShapeThickOutlineAsPolygon( const D_PAD* aPad,
} }
// For other shapes, draw polygon outlines // For other shapes, draw polygon outlines
CPOLYGONS_LIST corners; SHAPE_POLY_SET corners;
aPad->BuildPadShapePolygon( corners, wxSize( 0, 0 ), aPad->BuildPadShapePolygon( corners, wxSize( 0, 0 ),
aCircleToSegmentsCount, aCorrectionFactor ); aCircleToSegmentsCount, aCorrectionFactor );
// Add outlines as thick segments in polygon buffer // Add outlines as thick segments in polygon buffer
for( unsigned ii = 0, jj = corners.GetCornersCount() - 1;
ii < corners.GetCornersCount(); jj = ii, ii++ ) const SHAPE_LINE_CHAIN& path = corners.COutline( 0 );
for( int ii = 0; ii < path.PointCount(); ii++ )
{ {
const VECTOR2I& a = path.CPoint( ii );
const VECTOR2I& b = path.CPoint( ii + 1 );
TransformRoundedEndsSegmentToPolygon( aCornerBuffer, TransformRoundedEndsSegmentToPolygon( aCornerBuffer,
corners.GetPos( jj ), wxPoint( a.x, a.y ),
corners.GetPos( ii ), wxPoint( b.x, b.y ),
aCircleToSegmentsCount, aWidth ); aCircleToSegmentsCount, aWidth );
} }
} }

46
common/common_plotDXF_functions.cpp
View File

@ -346,8 +346,7 @@ void DXF_PLOTTER::Circle( const wxPoint& centre, int diameter, FILL_T fill, int
* It does not know thhick segments, therefore filled polygons with thick outline * It does not know thhick segments, therefore filled polygons with thick outline
* are converted to inflated polygon by aWidth/2 * are converted to inflated polygon by aWidth/2
*/ */
#include "clipper.hpp" void DXF_PLOTTER::PlotPoly( const std::vector<wxPoint>& aCornerList,
void DXF_PLOTTER::PlotPoly( const std::vector< wxPoint >& aCornerList,
FILL_T aFill, int aWidth) FILL_T aFill, int aWidth)
{ {
if( aCornerList.size() <= 1 ) if( aCornerList.size() <= 1 )
@ -392,10 +391,12 @@ void DXF_PLOTTER::PlotPoly( const std::vector< wxPoint >& aCornerList,
// The polygon outline has thickness, and is filled // The polygon outline has thickness, and is filled
// Build and plot the polygon which contains the initial // Build and plot the polygon which contains the initial
// polygon and its thick outline // polygon and its thick outline
CPOLYGONS_LIST bufferOutline; SHAPE_POLY_SET bufferOutline;
CPOLYGONS_LIST bufferPolybase; SHAPE_POLY_SET bufferPolybase;
const int circleToSegmentsCount = 16; const int circleToSegmentsCount = 16;
bufferPolybase.NewOutline();
// enter outline as polygon: // enter outline as polygon:
for( unsigned ii = 1; ii < aCornerList.size(); ii++ ) for( unsigned ii = 1; ii < aCornerList.size(); ii++ )
{ {
@ -406,47 +407,40 @@ void DXF_PLOTTER::PlotPoly( const std::vector< wxPoint >& aCornerList,
// enter the initial polygon: // enter the initial polygon:
for( unsigned ii = 0; ii < aCornerList.size(); ii++ ) for( unsigned ii = 0; ii < aCornerList.size(); ii++ )
{ {
CPolyPt polypoint( aCornerList[ii].x, aCornerList[ii].y ); bufferPolybase.Append( aCornerList[ii] );
bufferPolybase.Append( polypoint );
} }
bufferPolybase.CloseLastContour();
// Merge polygons to build the polygon which contains the initial // Merge polygons to build the polygon which contains the initial
// polygon and its thick outline // polygon and its thick outline
KI_POLYGON_SET polysBase; // Store the main outline and the final outline
KI_POLYGON_SET polysOutline; // Store the thick segments to draw the outline
bufferPolybase.ExportTo( polysBase );
bufferOutline.ExportTo( polysOutline );
polysBase += polysOutline; // create the outline which contains thick outline bufferPolybase.BooleanAdd( bufferOutline ); // create the outline which contains thick outline
bufferPolybase.Fracture();
// We should have only one polygon in list, now.
wxASSERT( polysBase.size() == 1 );
if( polysBase.size() < 1 ) // should not happen if( bufferPolybase.OutlineCount() < 1 ) // should not happen
return; return;
KI_POLYGON poly = polysBase[0]; // Expected only one polygon here const SHAPE_LINE_CHAIN& path = bufferPolybase.COutline( 0 );
if( poly.size() < 2 ) // should not happen if( path.PointCount() < 2 ) // should not happen
return; return;
// Now, output the final polygon to DXF file: // Now, output the final polygon to DXF file:
last = poly.size() - 1; last = path.PointCount() - 1;
KI_POLY_POINT point = *(poly.begin()); VECTOR2I point = path.CPoint( 0 );
wxPoint startPoint( point.x(), point.y() );
wxPoint startPoint( point.x, point.y );
MoveTo( startPoint ); MoveTo( startPoint );
for( unsigned ii = 1; ii < poly.size(); ii++ ) for( int ii = 1; ii < path.PointCount(); ii++ )
{ {
point = *( poly.begin() + ii ); point = path.CPoint( ii );
LineTo( wxPoint( point.x(), point.y() ) ); LineTo( wxPoint( point.x, point.y ) );
} }
// Close polygon, if needed // Close polygon, if needed
point = *(poly.begin() + last); point = path.CPoint( last );
wxPoint endPoint( point.x(), point.y() ); wxPoint endPoint( point.x, point.y );
if( endPoint != startPoint ) if( endPoint != startPoint )
LineTo( startPoint ); LineTo( startPoint );

54
common/convert_basic_shapes_to_polygon.cpp
View File

@ -43,7 +43,7 @@
* Note: the polygon is inside the circle, so if you want to have the polygon * Note: the polygon is inside the circle, so if you want to have the polygon
* outside the circle, you should give aRadius calculated with a corrrection factor * outside the circle, you should give aRadius calculated with a corrrection factor
*/ */
void TransformCircleToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformCircleToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aCenter, int aRadius, wxPoint aCenter, int aRadius,
int aCircleToSegmentsCount ) int aCircleToSegmentsCount )
{ {
@ -51,6 +51,8 @@ void TransformCircleToPolygon( CPOLYGONS_LIST& aCornerBuffer,
int delta = 3600 / aCircleToSegmentsCount; // rot angle in 0.1 degree int delta = 3600 / aCircleToSegmentsCount; // rot angle in 0.1 degree
int halfstep = 1800 / aCircleToSegmentsCount; // the starting value for rot angles int halfstep = 1800 / aCircleToSegmentsCount; // the starting value for rot angles
aCornerBuffer.NewOutline();
for( int ii = 0; ii < aCircleToSegmentsCount; ii++ ) for( int ii = 0; ii < aCircleToSegmentsCount; ii++ )
{ {
corner_position.x = aRadius; corner_position.x = aRadius;
@ -58,11 +60,8 @@ void TransformCircleToPolygon( CPOLYGONS_LIST& aCornerBuffer,
int angle = (ii * delta) + halfstep; int angle = (ii * delta) + halfstep;
RotatePoint( &corner_position.x, &corner_position.y, angle ); RotatePoint( &corner_position.x, &corner_position.y, angle );
corner_position += aCenter; corner_position += aCenter;
CPolyPt polypoint( corner_position.x, corner_position.y ); aCornerBuffer.Append( corner_position.x, corner_position.y );
aCornerBuffer.Append( polypoint );
} }
aCornerBuffer.CloseLastContour();
} }
@ -78,7 +77,7 @@ void TransformCircleToPolygon( CPOLYGONS_LIST& aCornerBuffer,
* Note: the polygon is inside the arc ends, so if you want to have the polygon * Note: the polygon is inside the arc ends, so if you want to have the polygon
* outside the circle, you should give aStart and aEnd calculated with a correction factor * outside the circle, you should give aStart and aEnd calculated with a correction factor
*/ */
void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformRoundedEndsSegmentToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aStart, wxPoint aEnd, wxPoint aStart, wxPoint aEnd,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
int aWidth ) int aWidth )
@ -87,7 +86,9 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
wxPoint endp = aEnd - aStart; // end point coordinate for the same segment starting at (0,0) wxPoint endp = aEnd - aStart; // end point coordinate for the same segment starting at (0,0)
wxPoint startp = aStart; wxPoint startp = aStart;
wxPoint corner; wxPoint corner;
CPolyPt polypoint; VECTOR2I polypoint;
aCornerBuffer.NewOutline();
// normalize the position in order to have endp.x >= 0; // normalize the position in order to have endp.x >= 0;
if( endp.x < 0 ) if( endp.x < 0 )
@ -112,7 +113,7 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
corner += startp; corner += startp;
polypoint.x = corner.x; polypoint.x = corner.x;
polypoint.y = corner.y; polypoint.y = corner.y;
aCornerBuffer.Append( polypoint ); aCornerBuffer.Append( polypoint.x, polypoint.y );
} }
// Finish arc: // Finish arc:
@ -121,7 +122,7 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
corner += startp; corner += startp;
polypoint.x = corner.x; polypoint.x = corner.x;
polypoint.y = corner.y; polypoint.y = corner.y;
aCornerBuffer.Append( polypoint ); aCornerBuffer.Append( polypoint.x, polypoint.y );
// add left rounded end: // add left rounded end:
for( int ii = 0; ii < 1800; ii += delta ) for( int ii = 0; ii < 1800; ii += delta )
@ -132,7 +133,7 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
corner += startp; corner += startp;
polypoint.x = corner.x; polypoint.x = corner.x;
polypoint.y = corner.y; polypoint.y = corner.y;
aCornerBuffer.Append( polypoint ); aCornerBuffer.Append( polypoint.x, polypoint.y );
} }
// Finish arc: // Finish arc:
@ -141,9 +142,7 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
corner += startp; corner += startp;
polypoint.x = corner.x; polypoint.x = corner.x;
polypoint.y = corner.y; polypoint.y = corner.y;
aCornerBuffer.Append( polypoint ); aCornerBuffer.Append( polypoint.x, polypoint.y );
aCornerBuffer.CloseLastContour();
} }
@ -158,7 +157,7 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
* @param aCircleToSegmentsCount = the number of segments to approximate a circle * @param aCircleToSegmentsCount = the number of segments to approximate a circle
* @param aWidth = width (thickness) of the line * @param aWidth = width (thickness) of the line
*/ */
void TransformArcToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformArcToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aCentre, wxPoint aStart, double aArcAngle, wxPoint aCentre, wxPoint aStart, double aArcAngle,
int aCircleToSegmentsCount, int aWidth ) int aCircleToSegmentsCount, int aWidth )
{ {
@ -208,7 +207,7 @@ void TransformArcToPolygon( CPOLYGONS_LIST& aCornerBuffer,
* @param aCircleToSegmentsCount = the number of segments to approximate a circle * @param aCircleToSegmentsCount = the number of segments to approximate a circle
* @param aWidth = width (thickness) of the ring * @param aWidth = width (thickness) of the ring
*/ */
void TransformRingToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformRingToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aCentre, int aRadius, wxPoint aCentre, int aRadius,
int aCircleToSegmentsCount, int aWidth ) int aCircleToSegmentsCount, int aWidth )
{ {
@ -218,7 +217,8 @@ void TransformRingToPolygon( CPOLYGONS_LIST& aCornerBuffer,
wxPoint curr_point; wxPoint curr_point;
int inner_radius = aRadius - ( aWidth / 2 ); int inner_radius = aRadius - ( aWidth / 2 );
int outer_radius = inner_radius + aWidth; int outer_radius = inner_radius + aWidth;
CPolyPt polycorner;
aCornerBuffer.NewOutline();
// Draw the inner circle of the ring // Draw the inner circle of the ring
for( int ii = 0; ii < 3600; ii += delta ) for( int ii = 0; ii < 3600; ii += delta )
@ -227,15 +227,11 @@ void TransformRingToPolygon( CPOLYGONS_LIST& aCornerBuffer,
curr_point.y = 0; curr_point.y = 0;
RotatePoint( &curr_point, ii ); RotatePoint( &curr_point, ii );
curr_point += aCentre; curr_point += aCentre;
polycorner.x = curr_point.x; aCornerBuffer.Append( curr_point.x, curr_point.y );
polycorner.y = curr_point.y;
aCornerBuffer.Append( polycorner );
} }
// Draw the last point of inner circle // Draw the last point of inner circle
polycorner.x = aCentre.x + inner_radius; aCornerBuffer.Append( aCentre.x + inner_radius, aCentre.y );
polycorner.y = aCentre.y;
aCornerBuffer.Append( polycorner );
// Draw the outer circle of the ring // Draw the outer circle of the ring
for( int ii = 0; ii < 3600; ii += delta ) for( int ii = 0; ii < 3600; ii += delta )
@ -244,18 +240,10 @@ void TransformRingToPolygon( CPOLYGONS_LIST& aCornerBuffer,
curr_point.y = 0; curr_point.y = 0;
RotatePoint( &curr_point, -ii ); RotatePoint( &curr_point, -ii );
curr_point += aCentre; curr_point += aCentre;
polycorner.x = curr_point.x; aCornerBuffer.Append( curr_point.x, curr_point.y );
polycorner.y = curr_point.y;
aCornerBuffer.Append( polycorner );
} }
// Draw the last point of outer circle // Draw the last point of outer circle
polycorner.x = aCentre.x + outer_radius; aCornerBuffer.Append( aCentre.x + outer_radius, aCentre.y );
polycorner.y = aCentre.y; aCornerBuffer.Append( aCentre.x + inner_radius, aCentre.y );
aCornerBuffer.Append( polycorner );
// Close the polygon
polycorner.x = aCentre.x + inner_radius;
polycorner.end_contour = true;
aCornerBuffer.Append( polycorner );
} }

419
common/geometry/shape_poly_set.cpp
View File

@ -4,6 +4,9 @@
* Copyright (C) 2015 CERN * Copyright (C) 2015 CERN
* @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch> * @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
* *
* Point in polygon algorithm adapted from Clipper Library (C) Angus Johnson,
* subject to Clipper library license.
*
* This program is free software; you can redistribute it and/or * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2 * as published by the Free Software Foundation; either version 2
@ -25,22 +28,34 @@
#include <vector> #include <vector>
#include <cstdio> #include <cstdio>
#include <geometry/shape.h>
#include <geometry/shape_line_chain.h>
#include <set> #include <set>
#include <list> #include <list>
#include <algorithm> #include <algorithm>
#include <boost/foreach.hpp> #include <boost/foreach.hpp>
#include "geometry/shape_poly_set.h" #include <geometry/shape.h>
#include <geometry/shape_line_chain.h>
#include <geometry/shape_poly_set.h>
using namespace ClipperLib; using namespace ClipperLib;
SHAPE_POLY_SET::SHAPE_POLY_SET() :
SHAPE( SH_POLY_SET )
{
}
SHAPE_POLY_SET::~SHAPE_POLY_SET()
{
}
int SHAPE_POLY_SET::NewOutline() int SHAPE_POLY_SET::NewOutline()
{ {
Path empty_path; SHAPE_LINE_CHAIN empty_path;
Paths poly; POLYGON poly;
poly.push_back( empty_path ); poly.push_back( empty_path );
m_polys.push_back( poly ); m_polys.push_back( poly );
return m_polys.size() - 1; return m_polys.size() - 1;
@ -49,12 +64,13 @@ int SHAPE_POLY_SET::NewOutline()
int SHAPE_POLY_SET::NewHole( int aOutline ) int SHAPE_POLY_SET::NewHole( int aOutline )
{ {
assert( false ); m_polys.back().push_back( SHAPE_LINE_CHAIN() );
return -1;
return m_polys.back().size() - 2;
} }
int SHAPE_POLY_SET::AppendVertex( int x, int y, int aOutline, int aHole ) int SHAPE_POLY_SET::Append( int x, int y, int aOutline, int aHole )
{ {
if( aOutline < 0 ) if( aOutline < 0 )
aOutline += m_polys.size(); aOutline += m_polys.size();
@ -69,13 +85,13 @@ int SHAPE_POLY_SET::AppendVertex( int x, int y, int aOutline, int aHole )
assert( aOutline < (int)m_polys.size() ); assert( aOutline < (int)m_polys.size() );
assert( idx < (int)m_polys[aOutline].size() ); assert( idx < (int)m_polys[aOutline].size() );
m_polys[aOutline][idx].push_back( IntPoint( x, y ) ); m_polys[aOutline][idx].Append( x, y );
return m_polys[aOutline][idx].size(); return m_polys[aOutline][idx].PointCount();
} }
int SHAPE_POLY_SET::VertexCount( int aOutline, int aHole ) const int SHAPE_POLY_SET::VertexCount( int aOutline , int aHole ) const
{ {
if( aOutline < 0 ) if( aOutline < 0 )
aOutline += m_polys.size(); aOutline += m_polys.size();
@ -90,11 +106,11 @@ int SHAPE_POLY_SET::VertexCount( int aOutline, int aHole ) const
assert ( aOutline < (int)m_polys.size() ); assert ( aOutline < (int)m_polys.size() );
assert ( idx < (int)m_polys[aOutline].size() ); assert ( idx < (int)m_polys[aOutline].size() );
return m_polys[aOutline][idx].size(); return m_polys[aOutline][idx].PointCount();
} }
const VECTOR2I SHAPE_POLY_SET::GetVertex( int index, int aOutline, int aHole ) const const VECTOR2I& SHAPE_POLY_SET::CVertex( int index, int aOutline , int aHole ) const
{ {
if( aOutline < 0 ) if( aOutline < 0 )
aOutline += m_polys.size(); aOutline += m_polys.size();
@ -109,8 +125,26 @@ const VECTOR2I SHAPE_POLY_SET::GetVertex( int index, int aOutline, int aHole ) c
assert( aOutline < (int)m_polys.size() ); assert( aOutline < (int)m_polys.size() );
assert( idx < (int)m_polys[aOutline].size() ); assert( idx < (int)m_polys[aOutline].size() );
IntPoint p = m_polys[aOutline][idx][index]; return m_polys[aOutline][idx].CPoint( index );
return VECTOR2I (p.X, p.Y); }
VECTOR2I& SHAPE_POLY_SET::Vertex( int index, int aOutline , int aHole )
{
if( aOutline < 0 )
aOutline += m_polys.size();
int idx;
if( aHole < 0 )
idx = 0;
else
idx = aHole + 1;
assert( aOutline < (int)m_polys.size() );
assert( idx < (int)m_polys[aOutline].size() );
return m_polys[aOutline][idx].Point( index );
} }
@ -118,13 +152,9 @@ int SHAPE_POLY_SET::AddOutline( const SHAPE_LINE_CHAIN& aOutline )
{ {
assert( aOutline.IsClosed() ); assert( aOutline.IsClosed() );
Path p = convert( aOutline ); POLYGON poly;
Paths poly;
if( !Orientation( p ) ) poly.push_back( aOutline );
ReversePath( p ); // outlines are always CW
poly.push_back( p );
m_polys.push_back( poly ); m_polys.push_back( poly );
@ -139,49 +169,60 @@ int SHAPE_POLY_SET::AddHole( const SHAPE_LINE_CHAIN& aHole, int aOutline )
if( aOutline < 0 ) if( aOutline < 0 )
aOutline += m_polys.size(); aOutline += m_polys.size();
Paths& poly = m_polys[aOutline]; POLYGON& poly = m_polys[aOutline];
assert( poly.size() ); assert( poly.size() );
Path p = convert( aHole ); poly.push_back( aHole );
if( Orientation( p ) )
ReversePath( p ); // holes are always CCW
poly.push_back( p );
return poly.size() - 1; return poly.size() - 1;
} }
const ClipperLib::Path SHAPE_POLY_SET::convert( const SHAPE_LINE_CHAIN& aPath ) const Path SHAPE_POLY_SET::convertToClipper( const SHAPE_LINE_CHAIN& aPath, bool aRequiredOrientation )
{ {
Path c_path; Path c_path;
for( int i = 0; i < aPath.PointCount(); i++ ) for( int i = 0; i < aPath.PointCount(); i++ )
{ {
const VECTOR2I& vertex = aPath.CPoint( i ); const VECTOR2I& vertex = aPath.CPoint( i );
c_path.push_back( ClipperLib::IntPoint( vertex.x, vertex.y ) ); c_path.push_back( IntPoint( vertex.x, vertex.y ) );
} }
if( Orientation( c_path ) != aRequiredOrientation )
ReversePath( c_path );
return c_path; return c_path;
} }
void SHAPE_POLY_SET::booleanOp( ClipperLib::ClipType type, const SHAPE_POLY_SET& b ) const SHAPE_LINE_CHAIN SHAPE_POLY_SET::convertFromClipper( const Path& aPath )
{
SHAPE_LINE_CHAIN lc;
for( unsigned int i = 0; i < aPath.size(); i++ )
lc.Append( aPath[i].X, aPath[i].Y );
return lc;
}
void SHAPE_POLY_SET::booleanOp( ClipType type, const SHAPE_POLY_SET& b )
{ {
Clipper c; Clipper c;
c.StrictlySimple( true ); c.StrictlySimple( true );
BOOST_FOREACH( Paths& subject, m_polys ) BOOST_FOREACH( const POLYGON& poly, m_polys )
{ {
c.AddPaths( subject, ptSubject, true ); for( unsigned int i = 0; i < poly.size(); i++ )
c.AddPath( convertToClipper( poly[i], i > 0 ? false : true ), ptSubject, true );
} }
BOOST_FOREACH( const Paths& clip, b.m_polys ) BOOST_FOREACH( const POLYGON& poly, b.m_polys )
{ {
c.AddPaths( clip, ptClip, true ); for( unsigned int i = 0; i < poly.size(); i++ )
c.AddPath( convertToClipper( poly[i], i > 0 ? false : true ), ptClip, true );
} }
PolyTree solution; PolyTree solution;
@ -192,41 +233,39 @@ void SHAPE_POLY_SET::booleanOp( ClipperLib::ClipType type, const SHAPE_POLY_SET&
} }
void SHAPE_POLY_SET::Add( const SHAPE_POLY_SET& b ) void SHAPE_POLY_SET::BooleanAdd( const SHAPE_POLY_SET& b )
{ {
booleanOp( ctUnion, b ); booleanOp( ctUnion, b );
} }
void SHAPE_POLY_SET::Subtract( const SHAPE_POLY_SET& b ) void SHAPE_POLY_SET::BooleanSubtract( const SHAPE_POLY_SET& b )
{ {
booleanOp( ctDifference, b ); booleanOp( ctDifference, b );
} }
void SHAPE_POLY_SET::Erode( int aFactor ) void SHAPE_POLY_SET::Inflate( int aFactor, int aCircleSegmentsCount )
{ {
ClipperOffset c; ClipperOffset c;
BOOST_FOREACH( Paths& p, m_polys ) BOOST_FOREACH( const POLYGON& poly, m_polys )
c.AddPaths(p, jtRound, etClosedPolygon ); {
for( unsigned int i = 0; i < poly.size(); i++ )
c.AddPath( convertToClipper( poly[i], i > 0 ? false : true ), jtRound, etClosedPolygon );
}
PolyTree solution; PolyTree solution;
c.ArcTolerance = (double)aFactor / M_PI / aCircleSegmentsCount;
c.Execute( solution, aFactor ); c.Execute( solution, aFactor );
m_polys.clear(); importTree( &solution );
for( PolyNode* n = solution.GetFirst(); n; n = n->GetNext() )
{
Paths ps;
ps.push_back( n->Contour );
m_polys.push_back( ps );
}
} }
void SHAPE_POLY_SET::importTree( ClipperLib::PolyTree* tree ) void SHAPE_POLY_SET::importTree( PolyTree* tree)
{ {
m_polys.clear(); m_polys.clear();
@ -234,37 +273,37 @@ void SHAPE_POLY_SET::importTree( ClipperLib::PolyTree* tree )
{ {
if( !n->IsHole() ) if( !n->IsHole() )
{ {
Paths paths; POLYGON paths;
paths.push_back( n->Contour ); paths.push_back( convertFromClipper( n->Contour ) );
for( unsigned i = 0; i < n->Childs.size(); i++ ) for( unsigned int i = 0; i < n->Childs.size(); i++ )
paths.push_back( n->Childs[i]->Contour ); paths.push_back( convertFromClipper( n->Childs[i]->Contour ) );
m_polys.push_back( paths ); m_polys.push_back(paths);
} }
} }
} }
// Polygon fracturing code. Work in progress. // Polygon fracturing code. Work in progress.
struct FractureEdge struct FractureEdge
{ {
FractureEdge( bool connected, Path* owner, int index ) : FractureEdge( bool connected, SHAPE_LINE_CHAIN* owner, int index ) :
m_connected( connected ), m_connected( connected ),
m_next( NULL ) m_next( NULL )
{ {
m_p1 = (*owner)[index]; m_p1 = owner->CPoint( index );
m_p2 = (*owner)[(index + 1) % owner->size()]; m_p2 = owner->CPoint( index + 1 );
} }
FractureEdge( int64_t y = 0 ) : FractureEdge( int y = 0 ) :
m_connected( false ), m_connected( false ),
m_next( NULL ) m_next( NULL )
{ {
m_p1.Y = m_p2.Y = y; m_p1.x = m_p2.y = y;
} }
FractureEdge( bool connected, const IntPoint& p1, const IntPoint& p2 ) : FractureEdge( bool connected, const VECTOR2I& p1, const VECTOR2I& p2 ) :
m_connected( connected ), m_connected( connected ),
m_p1( p1 ), m_p1( p1 ),
m_p2( p2 ), m_p2( p2 ),
@ -274,14 +313,14 @@ struct FractureEdge
bool matches( int y ) const bool matches( int y ) const
{ {
int y_min = std::min( m_p1.Y, m_p2.Y ); int y_min = std::min( m_p1.y, m_p2.y );
int y_max = std::max( m_p1.Y, m_p2.Y ); int y_max = std::max( m_p1.y, m_p2.y );
return ( y >= y_min ) && ( y <= y_max ); return ( y >= y_min ) && ( y <= y_max );
} }
bool m_connected; bool m_connected;
IntPoint m_p1, m_p2; VECTOR2I m_p1, m_p2;
FractureEdge* m_next; FractureEdge* m_next;
}; };
@ -290,10 +329,10 @@ typedef std::vector<FractureEdge*> FractureEdgeSet;
static int processEdge( FractureEdgeSet& edges, FractureEdge* edge ) static int processEdge( FractureEdgeSet& edges, FractureEdge* edge )
{ {
int64_t x = edge->m_p1.X; int x = edge->m_p1.x;
int64_t y = edge->m_p1.Y; int y = edge->m_p1.y;
int64_t min_dist = std::numeric_limits<int64_t>::max(); int min_dist = std::numeric_limits<int>::max();
int64_t x_nearest = 0; int x_nearest = 0;
FractureEdge* e_nearest = NULL; FractureEdge* e_nearest = NULL;
@ -302,15 +341,14 @@ static int processEdge( FractureEdgeSet& edges, FractureEdge* edge )
if( !(*i)->matches( y ) ) if( !(*i)->matches( y ) )
continue; continue;
int64_t x_intersect; int x_intersect;
if( (*i)->m_p1.Y == (*i)->m_p2.Y ) // horizontal edge if( (*i)->m_p1.y == (*i)->m_p2.y ) // horizontal edge
x_intersect = std::max( (*i)->m_p1.X, (*i)->m_p2.X ); x_intersect = std::max ( (*i)->m_p1.x, (*i)->m_p2.x );
else else
x_intersect = (*i)->m_p1.X + rescale((*i)->m_p2.X - (*i)->m_p1.X, x_intersect = (*i)->m_p1.x + rescale((*i)->m_p2.x - (*i)->m_p1.x, y - (*i)->m_p1.y, (*i)->m_p2.y - (*i)->m_p1.y );
y - (*i)->m_p1.Y, (*i)->m_p2.Y - (*i)->m_p1.Y );
int64_t dist = ( x - x_intersect ); int dist = ( x - x_intersect );
if( dist > 0 && dist < min_dist ) if( dist > 0 && dist < min_dist )
{ {
@ -324,9 +362,9 @@ static int processEdge( FractureEdgeSet& edges, FractureEdge* edge )
{ {
int count = 0; int count = 0;
FractureEdge* lead1 = new FractureEdge( true, IntPoint( x_nearest, y), IntPoint( x, y ) ); FractureEdge* lead1 = new FractureEdge( true, VECTOR2I( x_nearest, y ), VECTOR2I( x, y ) );
FractureEdge* lead2 = new FractureEdge( true, IntPoint( x, y), IntPoint( x_nearest, y ) ); FractureEdge* lead2 = new FractureEdge( true, VECTOR2I( x, y ), VECTOR2I( x_nearest, y ) );
FractureEdge* split_2 = new FractureEdge( true, IntPoint( x_nearest, y ), e_nearest->m_p2 ); FractureEdge* split_2 = new FractureEdge( true, VECTOR2I( x_nearest, y ), e_nearest->m_p2 );
edges.push_back( split_2 ); edges.push_back( split_2 );
edges.push_back( lead1 ); edges.push_back( lead1 );
@ -334,11 +372,11 @@ static int processEdge( FractureEdgeSet& edges, FractureEdge* edge )
FractureEdge* link = e_nearest->m_next; FractureEdge* link = e_nearest->m_next;
e_nearest->m_p2 = IntPoint( x_nearest, y ); e_nearest->m_p2 = VECTOR2I( x_nearest, y );
e_nearest->m_next = lead1; e_nearest->m_next = lead1;
lead1->m_next = edge; lead1->m_next = edge;
FractureEdge* last;
FractureEdge*last;
for( last = edge; last->m_next != edge; last = last->m_next ) for( last = edge; last->m_next != edge; last = last->m_next )
{ {
last->m_connected = true; last->m_connected = true;
@ -356,8 +394,7 @@ static int processEdge( FractureEdgeSet& edges, FractureEdge* edge )
return 0; return 0;
} }
void SHAPE_POLY_SET::fractureSingle( POLYGON& paths )
void SHAPE_POLY_SET::fractureSingle( ClipperLib::Paths& paths )
{ {
FractureEdgeSet edges; FractureEdgeSet edges;
FractureEdgeSet border_edges; FractureEdgeSet border_edges;
@ -370,21 +407,23 @@ void SHAPE_POLY_SET::fractureSingle( ClipperLib::Paths& paths )
int num_unconnected = 0; int num_unconnected = 0;
BOOST_FOREACH( Path& path, paths ) BOOST_FOREACH( SHAPE_LINE_CHAIN& path, paths )
{ {
int index = 0; int index = 0;
FractureEdge *prev = NULL, *first_edge = NULL; FractureEdge *prev = NULL, *first_edge = NULL;
int64_t x_min = std::numeric_limits<int64_t>::max(); int x_min = std::numeric_limits<int>::max();
for( unsigned i = 0; i < path.size(); i++ ) for( int i = 0; i < path.PointCount(); i++ )
{ {
if( path[i].X < x_min ) const VECTOR2I& p = path.CPoint( i );
x_min = path[i].X;
if( p.x < x_min )
x_min = p.x;
} }
for( unsigned i = 0; i < path.size(); i++ ) for( int i = 0; i < path.PointCount(); i++ )
{ {
FractureEdge* fe = new FractureEdge( first, &path, index++ ); FractureEdge* fe = new FractureEdge( first, &path, index++ );
@ -397,7 +436,7 @@ void SHAPE_POLY_SET::fractureSingle( ClipperLib::Paths& paths )
if( prev ) if( prev )
prev->m_next = fe; prev->m_next = fe;
if( i == path.size() - 1 ) if( i == path.PointCount() - 1 )
fe->m_next = first_edge; fe->m_next = first_edge;
prev = fe; prev = fe;
@ -405,27 +444,27 @@ void SHAPE_POLY_SET::fractureSingle( ClipperLib::Paths& paths )
if( !first ) if( !first )
{ {
if( fe->m_p1.X == x_min ) if( fe->m_p1.x == x_min )
border_edges.push_back( fe ); border_edges.push_back( fe );
} }
if( !fe->m_connected ) if( !fe->m_connected )
num_unconnected++; num_unconnected++;
} }
first = false; // first path is always the outline first = false; // first path is always the outline
} }
// keep connecting holes to the main outline, until there's no holes left... // keep connecting holes to the main outline, until there's no holes left...
while( num_unconnected > 0 ) while( num_unconnected > 0 )
{ {
int64_t x_min = std::numeric_limits<int64_t>::max(); int x_min = std::numeric_limits<int>::max();
FractureEdge* smallestX = NULL; FractureEdge* smallestX = NULL;
// find the left-most hole edge and merge with the outline // find the left-most hole edge and merge with the outline
for( FractureEdgeSet::iterator i = border_edges.begin(); i != border_edges.end(); ++i ) for( FractureEdgeSet::iterator i = border_edges.begin(); i != border_edges.end(); ++i )
{ {
int64_t xt = (*i)->m_p1.X; int xt = (*i)->m_p1.x;
if( ( xt < x_min ) && ! (*i)->m_connected ) if( ( xt < x_min ) && ! (*i)->m_connected )
{ {
@ -438,13 +477,16 @@ void SHAPE_POLY_SET::fractureSingle( ClipperLib::Paths& paths )
} }
paths.clear(); paths.clear();
Path newPath; SHAPE_LINE_CHAIN newPath;
newPath.SetClosed( true );
FractureEdge* e; FractureEdge* e;
for( e = root; e->m_next != root; e = e->m_next ) for( e = root; e->m_next != root; e = e->m_next )
newPath.push_back( e->m_p1 ); newPath.Append( e->m_p1 );
newPath.push_back( e->m_p1 ); newPath.Append( e->m_p1 );
for( FractureEdgeSet::iterator i = edges.begin(); i != edges.end(); ++i ) for( FractureEdgeSet::iterator i = edges.begin(); i != edges.end(); ++i )
delete *i; delete *i;
@ -455,7 +497,9 @@ void SHAPE_POLY_SET::fractureSingle( ClipperLib::Paths& paths )
void SHAPE_POLY_SET::Fracture() void SHAPE_POLY_SET::Fracture()
{ {
BOOST_FOREACH( Paths& paths, m_polys ) Simplify(); // remove overlallping holes/degeneracy
BOOST_FOREACH( POLYGON& paths, m_polys )
{ {
fractureSingle( paths ); fractureSingle( paths );
} }
@ -464,12 +508,9 @@ void SHAPE_POLY_SET::Fracture()
void SHAPE_POLY_SET::Simplify() void SHAPE_POLY_SET::Simplify()
{ {
for( unsigned i = 0; i < m_polys.size(); i++ ) SHAPE_POLY_SET empty;
{
Paths out; booleanOp( ctUnion, empty );
SimplifyPolygons( m_polys[i], out, pftNonZero );
m_polys[i] = out;
}
} }
@ -482,13 +523,11 @@ const std::string SHAPE_POLY_SET::Format() const
for( unsigned i = 0; i < m_polys.size(); i++ ) for( unsigned i = 0; i < m_polys.size(); i++ )
{ {
ss << "poly " << m_polys[i].size() << "\n"; ss << "poly " << m_polys[i].size() << "\n";
for( unsigned j = 0; j < m_polys[i].size(); j++) for( unsigned j = 0; j < m_polys[i].size(); j++)
{ {
ss << m_polys[i][j].size() << "\n"; ss << m_polys[i][j].PointCount() << "\n";
for( int v = 0; v < m_polys[i][j].PointCount(); v++)
for( unsigned v = 0; v < m_polys[i][j].size(); v++) ss << m_polys[i][j].CPoint( v ).x << " " << m_polys[i][j].CPoint( v ).y << "\n";
ss << m_polys[i][j][v].X << " " << m_polys[i][j][v].Y << "\n";
} }
ss << "\n"; ss << "\n";
} }
@ -515,7 +554,8 @@ bool SHAPE_POLY_SET::Parse( std::stringstream& aStream )
for( int i = 0; i < n_polys; i++ ) for( int i = 0; i < n_polys; i++ )
{ {
ClipperLib::Paths paths; POLYGON paths;
aStream >> tmp; aStream >> tmp;
if( tmp != "poly" ) if( tmp != "poly" )
@ -529,23 +569,26 @@ bool SHAPE_POLY_SET::Parse( std::stringstream& aStream )
for( int j = 0; j < n_outlines; j++ ) for( int j = 0; j < n_outlines; j++ )
{ {
ClipperLib::Path outline; SHAPE_LINE_CHAIN outline;
outline.SetClosed( true );
aStream >> tmp; aStream >> tmp;
int n_vertices = atoi( tmp.c_str() ); int n_vertices = atoi( tmp.c_str() );
for( int v = 0; v < n_vertices; v++ ) for( int v = 0; v < n_vertices; v++ )
{ {
ClipperLib::IntPoint p; VECTOR2I p;
aStream >> tmp; p.X = atoi( tmp.c_str() ); aStream >> tmp; p.x = atoi( tmp.c_str() );
aStream >> tmp; p.Y = atoi( tmp.c_str() ); aStream >> tmp; p.y = atoi( tmp.c_str() );
outline.push_back( p ); outline.Append( p );
} }
paths.push_back( outline ); paths.push_back( outline );
} }
m_polys.push_back( paths ); m_polys.push_back( paths );
} }
return true; return true;
} }
@ -557,22 +600,146 @@ const BOX2I SHAPE_POLY_SET::BBox( int aClearance ) const
for( unsigned i = 0; i < m_polys.size(); i++ ) for( unsigned i = 0; i < m_polys.size(); i++ )
{ {
for( unsigned j = 0; j < m_polys[i].size(); j++)
{
for( unsigned v = 0; v < m_polys[i][j].size(); v++)
{
VECTOR2I p( m_polys[i][j][v].X, m_polys[i][j][v].Y );
if( first ) if( first )
bb = BOX2I( p, VECTOR2I( 0, 0 ) ); bb = m_polys[i][0].BBox();
else else
bb.Merge( p ); bb.Merge( m_polys[i][0].BBox() );
first = false;
}
}
} }
bb.Inflate( aClearance ); bb.Inflate( aClearance );
return bb; return bb;
} }
void SHAPE_POLY_SET::RemoveAllContours()
{
m_polys.clear();
}
void SHAPE_POLY_SET::DeletePolygon( int aIdx )
{
m_polys.erase( m_polys.begin() + aIdx );
}
void SHAPE_POLY_SET::Append( const SHAPE_POLY_SET& aSet )
{
m_polys.insert( m_polys.end(), aSet.m_polys.begin(), aSet.m_polys.end() );
}
void SHAPE_POLY_SET::Append( const VECTOR2I& aP, int aOutline, int aHole )
{
Append( aP.x, aP.y, aOutline, aHole );
}
bool SHAPE_POLY_SET::Contains( const VECTOR2I& aP, int aSubpolyIndex ) const
{
// fixme: support holes!
if( aSubpolyIndex >= 0 )
return pointInPolygon( aP, m_polys[aSubpolyIndex][0] );
BOOST_FOREACH ( const POLYGON& polys, m_polys )
{
if( pointInPolygon( aP, polys[0] ) )
return true;
}
return false;
}
bool SHAPE_POLY_SET::pointInPolygon( const VECTOR2I& aP, const SHAPE_LINE_CHAIN& aPath ) const
{
int result = 0;
int cnt = aPath.PointCount();
if ( !aPath.BBox().Contains( aP ) ) // test with bounding box first
return false;
if( cnt < 3 )
return false;
VECTOR2I ip = aPath.CPoint( 0 );
for( int i = 1; i <= cnt; ++i )
{
VECTOR2I ipNext = ( i == cnt ? aPath.CPoint( 0 ) : aPath.CPoint( i ) );
if( ipNext.y == aP.y )
{
if( ( ipNext.x == aP.x ) || ( ip.y == aP.y &&
( ( ipNext.x > aP.x ) == ( ip.x < aP.x ) ) ) )
return true;
}
if( ( ip.y < aP.y ) != ( ipNext.y < aP.y ) )
{
if( ip.x >= aP.x )
{
if( ipNext.x > aP.x )
result = 1 - result;
else
{
int64_t d = (int64_t)( ip.x - aP.x ) * (int64_t)( ipNext.y - aP.y ) -
(int64_t)( ipNext.x - aP.x ) * (int64_t)( ip.y - aP.y );
if( !d )
return true;
if( ( d > 0 ) == ( ipNext.y > ip.y ) )
result = 1 - result;
}
}
else
{
if( ipNext.x > aP.x )
{
int64_t d = (int64_t)( ip.x - aP.x ) * (int64_t)( ipNext.y - aP.y ) -
(int64_t)( ipNext.x - aP.x ) * (int64_t)( ip.y - aP.y );
if( !d )
return -1;
if( ( d > 0 ) == ( ipNext.y > ip.y ) )
result = 1 - result;
}
}
}
ip = ipNext;
}
return result ? true : false;
}
void SHAPE_POLY_SET::Move( const VECTOR2I& aVector )
{
BOOST_FOREACH( POLYGON &poly, m_polys )
{
BOOST_FOREACH( SHAPE_LINE_CHAIN &path, poly )
{
path.Move( aVector );
}
}
}
int SHAPE_POLY_SET::TotalVertices() const
{
int c = 0;
BOOST_FOREACH( const POLYGON& poly, m_polys )
{
BOOST_FOREACH ( const SHAPE_LINE_CHAIN& path, poly )
{
c += path.PointCount();
}
}
return c;
}

1
gerbview/class_gerber_draw_item.cpp
View File

@ -27,7 +27,6 @@
*/ */
#include <fctsys.h> #include <fctsys.h>
#include <polygons_defs.h>
#include <gr_basic.h> #include <gr_basic.h>
#include <common.h> #include <common.h>
#include <trigo.h> #include <trigo.h>

10
include/convert_basic_shapes_to_polygon.h
View File

@ -33,8 +33,8 @@
#include <fctsys.h> #include <fctsys.h>
#include <trigo.h> #include <trigo.h>
#include <macros.h> #include <macros.h>
#include <PolyLine.h>
#include <geometry/shape_poly_set.h>
/** /**
* Function TransformCircleToPolygon * Function TransformCircleToPolygon
* convert a circle to a polygon, using multiple straight lines * convert a circle to a polygon, using multiple straight lines
@ -45,7 +45,7 @@
* Note: the polygon is inside the circle, so if you want to have the polygon * Note: the polygon is inside the circle, so if you want to have the polygon
* outside the circle, you should give aRadius calculated with a correction factor * outside the circle, you should give aRadius calculated with a correction factor
*/ */
void TransformCircleToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformCircleToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aCenter, int aRadius, wxPoint aCenter, int aRadius,
int aCircleToSegmentsCount ); int aCircleToSegmentsCount );
@ -61,7 +61,7 @@ void TransformCircleToPolygon( CPOLYGONS_LIST& aCornerBuffer,
* Note: the polygon is inside the arc ends, so if you want to have the polygon * Note: the polygon is inside the arc ends, so if you want to have the polygon
* outside the circle, you should give aStart and aEnd calculated with a correction factor * outside the circle, you should give aStart and aEnd calculated with a correction factor
*/ */
void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformRoundedEndsSegmentToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aStart, wxPoint aEnd, wxPoint aStart, wxPoint aEnd,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
int aWidth ); int aWidth );
@ -78,7 +78,7 @@ void TransformRoundedEndsSegmentToPolygon( CPOLYGONS_LIST& aCornerBuffer,
* @param aCircleToSegmentsCount = the number of segments to approximate a circle * @param aCircleToSegmentsCount = the number of segments to approximate a circle
* @param aWidth = width (thickness) of the line * @param aWidth = width (thickness) of the line
*/ */
void TransformArcToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformArcToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aCentre, wxPoint aStart, double aArcAngle, wxPoint aCentre, wxPoint aStart, double aArcAngle,
int aCircleToSegmentsCount, int aWidth ); int aCircleToSegmentsCount, int aWidth );
@ -92,7 +92,7 @@ void TransformArcToPolygon( CPOLYGONS_LIST& aCornerBuffer,
* @param aCircleToSegmentsCount = the number of segments to approximate a circle * @param aCircleToSegmentsCount = the number of segments to approximate a circle
* @param aWidth = width (thickness) of the ring * @param aWidth = width (thickness) of the ring
*/ */
void TransformRingToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformRingToPolygon( SHAPE_POLY_SET& aCornerBuffer,
wxPoint aCentre, int aRadius, wxPoint aCentre, int aRadius,
int aCircleToSegmentsCount, int aWidth ); int aCircleToSegmentsCount, int aWidth );

4
include/geometry/shape_line_chain.h
View File

@ -255,6 +255,9 @@ public:
if( aIndex < 0 ) if( aIndex < 0 )
aIndex += PointCount(); aIndex += PointCount();
if( aIndex >= PointCount() )
aIndex -= PointCount();
return m_points[aIndex]; return m_points[aIndex];
} }
@ -578,6 +581,7 @@ public:
{ {
return false; return false;
} }
private: private:
/// array of vertices /// array of vertices
std::vector<VECTOR2I> m_points; std::vector<VECTOR2I> m_points;

242
include/geometry/shape_poly_set.h
View File

@ -32,25 +32,103 @@
#include "clipper.hpp" #include "clipper.hpp"
/** /**
* Class SHAPE_POLY_SET * Class SHAPE_POLY_SET
* *
* Represents a set of closed polygons. Polygons may be nonconvex, self-intersecting * Represents a set of closed polygons. Polygons may be nonconvex, self-intersecting
* and have holes. Provides boolean operations (using Clipper library as the backend). * and have holes. Provides boolean operations (using Clipper library as the backend).
* *
* TODO: document, derive from class SHAPE, add convex partitioning & spatial index * TODO: add convex partitioning & spatial index
*/ */
class SHAPE_POLY_SET : public SHAPE class SHAPE_POLY_SET : public SHAPE
{ {
public: public:
SHAPE_POLY_SET() : SHAPE( SH_POLY_SET ) {}; ///> represents a single polygon outline with holes. The first entry is the outline,
~SHAPE_POLY_SET() {}; ///> the remaining (if any), are the holes
typedef std::vector<SHAPE_LINE_CHAIN> POLYGON;
/**
* Class ITERATOR_TEMPLATE
*
* Base class for iterating over all vertices in a given SHAPE_POLY_SET
*/
template <class T>
class ITERATOR_TEMPLATE {
public:
bool IsEndContour() const
{
return m_currentVertex + 1 == m_poly->CPolygon( m_currentOutline )[0].PointCount();
}
bool IsLastContour() const
{
return m_currentOutline == m_lastOutline;
}
operator bool() const
{
return m_currentOutline <= m_lastOutline;
}
void Advance()
{
m_currentVertex ++;
if( m_currentVertex >= m_poly->CPolygon( m_currentOutline )[0].PointCount() )
{
m_currentVertex = 0;
m_currentOutline++;
}
}
void operator++( int dummy )
{
Advance();
}
void operator++()
{
Advance();
}
T& Get()
{
return m_poly->Polygon( m_currentOutline )[0].Point( m_currentVertex );
}
T& operator*()
{
return Get();
}
T* operator->()
{
return &Get();
}
private:
friend class SHAPE_POLY_SET;
SHAPE_POLY_SET* m_poly;
int m_currentOutline;
int m_lastOutline;
int m_currentVertex;
};
typedef ITERATOR_TEMPLATE<VECTOR2I> ITERATOR;
typedef ITERATOR_TEMPLATE<const VECTOR2I> CONST_ITERATOR;
SHAPE_POLY_SET();
~SHAPE_POLY_SET();
///> Creates a new empty polygon in the set and returns its index ///> Creates a new empty polygon in the set and returns its index
int NewOutline(); int NewOutline();
///> Cretes a new empty hole in the given outline (default: last one) and returns its index ///> Creates a new hole in a given outline
int NewHole( int aOutline = -1); int NewHole( int aOutline = -1 );
///> Adds a new outline to the set and returns its index ///> Adds a new outline to the set and returns its index
int AddOutline( const SHAPE_LINE_CHAIN& aOutline ); int AddOutline( const SHAPE_LINE_CHAIN& aOutline );
@ -58,11 +136,20 @@ class SHAPE_POLY_SET : public SHAPE
///> Adds a new hole to the given outline (default: last) and returns its index ///> Adds a new hole to the given outline (default: last) and returns its index
int AddHole( const SHAPE_LINE_CHAIN& aHole, int aOutline = -1 ); int AddHole( const SHAPE_LINE_CHAIN& aHole, int aOutline = -1 );
///> Appends a vertex at the end of the given outline/hole (default: last hole in the last outline) ///> Appends a vertex at the end of the given outline/hole (default: the last outline)
int AppendVertex( int x, int y, int aOutline = -1, int aHole = -1 ); int Append( int x, int y, int aOutline = -1, int aHole = -1 );
///> Merges polygons from two sets.
void Append( const SHAPE_POLY_SET& aSet );
///> Appends a vertex at the end of the given outline/hole (default: the last outline)
void Append( const VECTOR2I& aP, int aOutline = -1, int aHole = -1 );
///> Returns the index-th vertex in a given hole outline within a given outline ///> Returns the index-th vertex in a given hole outline within a given outline
const VECTOR2I GetVertex( int index, int aOutline = -1, int aHole = -1) const; VECTOR2I& Vertex( int index, int aOutline = -1, int aHole = -1 );
///> Returns the index-th vertex in a given hole outline within a given outline
const VECTOR2I& CVertex( int index, int aOutline = -1, int aHole = -1 ) const;
///> Returns true if any of the outlines is self-intersecting ///> Returns true if any of the outlines is self-intersecting
bool IsSelfIntersecting(); bool IsSelfIntersecting();
@ -73,28 +160,109 @@ class SHAPE_POLY_SET : public SHAPE
///> Returns the number of vertices in a given outline/hole ///> Returns the number of vertices in a given outline/hole
int VertexCount( int aOutline = -1, int aHole = -1 ) const; int VertexCount( int aOutline = -1, int aHole = -1 ) const;
///> Returns the internal representation (ClipperLib) of a given polygon (outline + holes) ///> Returns the number of holes in a given outline
const ClipperLib::Paths& GetPoly( int aIndex ) const int HoleCount( int aOutline ) const;
///> Returns the reference to aIndex-th outline in the set
SHAPE_LINE_CHAIN& Outline( int aIndex )
{
return m_polys[aIndex][0];
}
///> Returns the reference to aHole-th hole in the aIndex-th outline
SHAPE_LINE_CHAIN& Hole( int aOutline, int aHole )
{
return m_polys[aOutline][aHole + 1];
}
///> Returns the aIndex-th subpolygon in the set
POLYGON& Polygon( int aIndex )
{ {
return m_polys[aIndex]; return m_polys[aIndex];
} }
///> Performs boolean polyset difference const SHAPE_LINE_CHAIN& COutline( int aIndex ) const
void Subtract( const SHAPE_POLY_SET& b ); {
return m_polys[aIndex][0];
}
const SHAPE_LINE_CHAIN& CHole( int aOutline, int aHole ) const
{
return m_polys[aOutline][aHole + 1];
}
const POLYGON& CPolygon( int aIndex ) const
{
return m_polys[aIndex];
}
///> Returns an iterator object, for iterating between aFirst and aLast outline.
ITERATOR Iterate( int aFirst, int aLast )
{
ITERATOR iter;
iter.m_poly = this;
iter.m_currentOutline = aFirst;
iter.m_lastOutline = aLast < 0 ? OutlineCount() - 1 : aLast;
iter.m_currentVertex = 0;
return iter;
}
///> Returns an iterator object, for iterating aOutline-th outline
ITERATOR Iterate( int aOutline )
{
return Iterate( aOutline, aOutline );
}
///> Returns an iterator object, for all outlines in the set (no holes)
ITERATOR Iterate()
{
return Iterate( 0, OutlineCount() - 1 );
}
CONST_ITERATOR CIterate( int aFirst, int aLast ) const
{
CONST_ITERATOR iter;
iter.m_poly = const_cast<SHAPE_POLY_SET*>( this );
iter.m_currentOutline = aFirst;
iter.m_lastOutline = aLast < 0 ? OutlineCount() - 1 : aLast;
iter.m_currentVertex = 0;
return iter;
}
CONST_ITERATOR CIterate( int aOutline ) const
{
return CIterate( aOutline, aOutline );
}
CONST_ITERATOR CIterate() const
{
return CIterate( 0, OutlineCount() - 1 );
}
///> Performs boolean polyset union ///> Performs boolean polyset union
void Add( const SHAPE_POLY_SET& b ); void BooleanAdd( const SHAPE_POLY_SET& b );
///> Performs smooth outline inflation (Minkowski sum of the outline and a circle of a given radius) ///> Performs boolean polyset difference
void SmoothInflate( int aFactor ); void BooleanSubtract( const SHAPE_POLY_SET& b );
///> Performs outline erosion/shrinking ///> Performs outline inflation/deflation, using round corners.
void Erode( int aFactor ); void Inflate ( int aFactor, int aCircleSegmentsCount = 32 );
///> Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the outer ring ///> Converts a set of polygons with holes to a singe outline with "slits"/"fractures" connecting the outer ring
///> to the inner holes ///> to the inner holes
void Fracture(); void Fracture();
///> Converts a set of slitted polygons to a set of polygons with holes
void Unfracture();
///> Returns true if the polygon set has any holes.
bool HasHoles() const;
///> Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections) ///> Simplifies the polyset (merges overlapping polys, eliminates degeneracy/self-intersections)
void Simplify(); void Simplify();
@ -104,8 +272,10 @@ class SHAPE_POLY_SET : public SHAPE
/// @copydoc SHAPE::Parse() /// @copydoc SHAPE::Parse()
bool Parse( std::stringstream& aStream ); bool Parse( std::stringstream& aStream );
void Move( const VECTOR2I& aVector ) { assert(false ); }; /// @copydoc SHAPE::Move()
void Move( const VECTOR2I& aVector );
/// @copydoc SHAPE::IsSolid()
bool IsSolid() const bool IsSolid() const
{ {
return true; return true;
@ -117,15 +287,43 @@ class SHAPE_POLY_SET : public SHAPE
bool Collide( const VECTOR2I& aP, int aClearance = 0 ) const { return false; } bool Collide( const VECTOR2I& aP, int aClearance = 0 ) const { return false; }
bool Collide( const SEG& aSeg, int aClearance = 0 ) const { return false; } bool Collide( const SEG& aSeg, int aClearance = 0 ) const { return false; }
///> Returns true is a given subpolygon contains the point aP. If aSubpolyIndex < 0 (default value),
///> checks all polygons in the set
bool Contains( const VECTOR2I& aP, int aSubpolyIndex = -1 ) const;
///> Returns true if the set is empty (no polygons at all)
bool IsEmpty() const
{
return m_polys.size() == 0;
}
///> Removes all outlines & holes (clears) the polygon set.
void RemoveAllContours();
///> Returns total number of vertices stored in the set.
int TotalVertices() const;
///> Deletes aIdx-th polygon from the set
void DeletePolygon( int aIdx );
private: private:
void fractureSingle( ClipperLib::Paths& paths ); SHAPE_LINE_CHAIN& getContourForCorner( int aCornerId, int& aIndexWithinContour );
void importTree( ClipperLib::PolyTree* tree); VECTOR2I& vertex( int aCornerId );
const VECTOR2I& cvertex( int aCornerId ) const;
void fractureSingle( POLYGON& paths );
void importTree( ClipperLib::PolyTree* tree );
void booleanOp( ClipperLib::ClipType type, const SHAPE_POLY_SET& b ); void booleanOp( ClipperLib::ClipType type, const SHAPE_POLY_SET& b );
const ClipperLib::Path convert( const SHAPE_LINE_CHAIN& aPath ); bool pointInPolygon( const VECTOR2I& aP, const SHAPE_LINE_CHAIN& aPath ) const;
typedef std::vector<ClipperLib::Paths> Polyset; const ClipperLib::Path convertToClipper( const SHAPE_LINE_CHAIN& aPath, bool aRequiredOrientation );
const SHAPE_LINE_CHAIN convertFromClipper( const ClipperLib::Path& aPath );
typedef std::vector<POLYGON> Polyset;
Polyset m_polys; Polyset m_polys;
}; };

184
pcbnew/board_items_to_polygon_shape_transform.cpp
View File

@ -33,7 +33,6 @@
#include <vector> #include <vector>
#include <fctsys.h> #include <fctsys.h>
#include <polygons_defs.h>
#include <drawtxt.h> #include <drawtxt.h>
#include <pcbnew.h> #include <pcbnew.h>
#include <wxPcbStruct.h> #include <wxPcbStruct.h>
@ -51,9 +50,9 @@
// These variables are parameters used in addTextSegmToPoly. // These variables are parameters used in addTextSegmToPoly.
// But addTextSegmToPoly is a call-back function, // But addTextSegmToPoly is a call-back function,
// so we cannot send them as arguments. // so we cannot send them as arguments.
int s_textWidth; static int s_textWidth;
int s_textCircle2SegmentCount; static int s_textCircle2SegmentCount;
CPOLYGONS_LIST* s_cornerBuffer; static SHAPE_POLY_SET* s_cornerBuffer;
// This is a call back function, used by DrawGraphicText to draw the 3D text shape: // This is a call back function, used by DrawGraphicText to draw the 3D text shape:
static void addTextSegmToPoly( int x0, int y0, int xf, int yf ) static void addTextSegmToPoly( int x0, int y0, int xf, int yf )
@ -64,7 +63,7 @@ static void addTextSegmToPoly( int x0, int y0, int xf, int yf )
} }
void BOARD::ConvertBrdLayerToPolygonalContours( LAYER_ID aLayer, CPOLYGONS_LIST& aOutlines ) void BOARD::ConvertBrdLayerToPolygonalContours( LAYER_ID aLayer, SHAPE_POLY_SET& aOutlines )
{ {
// Number of segments to convert a circle to a polygon // Number of segments to convert a circle to a polygon
const int segcountforcircle = 18; const int segcountforcircle = 18;
@ -128,7 +127,7 @@ void BOARD::ConvertBrdLayerToPolygonalContours( LAYER_ID aLayer, CPOLYGONS_LIST&
void MODULE::TransformPadsShapesWithClearanceToPolygon( LAYER_ID aLayer, void MODULE::TransformPadsShapesWithClearanceToPolygon( LAYER_ID aLayer,
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aInflateValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor, double aCorrectionFactor,
@ -203,7 +202,7 @@ void MODULE::TransformPadsShapesWithClearanceToPolygon( LAYER_ID aLayer,
*/ */
void MODULE::TransformGraphicShapesWithClearanceToPolygonSet( void MODULE::TransformGraphicShapesWithClearanceToPolygonSet(
LAYER_ID aLayer, LAYER_ID aLayer,
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aInflateValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) double aCorrectionFactor )
@ -280,44 +279,31 @@ void MODULE::TransformGraphicShapesWithClearanceToPolygonSet(
* keep arc radius when approximated by segments * keep arc radius when approximated by segments
*/ */
void ZONE_CONTAINER::TransformSolidAreasShapesToPolygonSet( void ZONE_CONTAINER::TransformSolidAreasShapesToPolygonSet(
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) double aCorrectionFactor )
{ {
unsigned cornerscount = GetFilledPolysList().GetCornersCount(); if( GetFilledPolysList().IsEmpty() )
if( cornerscount == 0 )
return; return;
// add filled areas polygons // add filled areas polygons
aCornerBuffer.Append( m_FilledPolysList ); aCornerBuffer.Append( m_FilledPolysList );
// add filled areas outlines, which are drawn with thick lines // add filled areas outlines, which are drawn with thick lines
wxPoint seg_start, seg_end; for( int i = 0; i < m_FilledPolysList.OutlineCount(); i++ )
int i_start_contour = 0;
for( unsigned ic = 0; ic < cornerscount; ic++ )
{ {
seg_start.x = m_FilledPolysList[ ic ].x; const SHAPE_LINE_CHAIN& path = m_FilledPolysList.COutline( i );
seg_start.y = m_FilledPolysList[ ic ].y;
unsigned ic_next = ic+1;
if( !m_FilledPolysList[ic].end_contour && for( int j = 0; j < path.PointCount(); j++ )
ic_next < cornerscount )
{ {
seg_end.x = m_FilledPolysList[ ic_next ].x; const VECTOR2I& a = path.CPoint( j );
seg_end.y = m_FilledPolysList[ ic_next ].y; const VECTOR2I& b = path.CPoint( j + 1 );
}
else
{
seg_end.x = m_FilledPolysList[ i_start_contour ].x;
seg_end.y = m_FilledPolysList[ i_start_contour ].y;
i_start_contour = ic_next;
}
TransformRoundedEndsSegmentToPolygon( aCornerBuffer, seg_start, seg_end, TransformRoundedEndsSegmentToPolygon( aCornerBuffer, wxPoint( a.x, a.y ), wxPoint( b.x, b.y ),
aCircleToSegmentsCount, aCircleToSegmentsCount,
GetMinThickness() ); GetMinThickness() );
} }
}
} }
/** /**
@ -329,13 +315,13 @@ void ZONE_CONTAINER::TransformSolidAreasShapesToPolygonSet(
* @param aClearanceValue = the clearance around the text bounding box * @param aClearanceValue = the clearance around the text bounding box
*/ */
void TEXTE_PCB::TransformBoundingBoxWithClearanceToPolygon( void TEXTE_PCB::TransformBoundingBoxWithClearanceToPolygon(
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue ) const int aClearanceValue ) const
{ {
if( GetText().Length() == 0 ) if( GetText().Length() == 0 )
return; return;
CPolyPt corners[4]; // Buffer of polygon corners wxPoint corners[4]; // Buffer of polygon corners
EDA_RECT rect = GetTextBox( -1 ); EDA_RECT rect = GetTextBox( -1 );
rect.Inflate( aClearanceValue ); rect.Inflate( aClearanceValue );
@ -348,14 +334,14 @@ void TEXTE_PCB::TransformBoundingBoxWithClearanceToPolygon(
corners[3].y = corners[2].y; corners[3].y = corners[2].y;
corners[3].x = corners[0].x; corners[3].x = corners[0].x;
aCornerBuffer.NewOutline();
for( int ii = 0; ii < 4; ii++ ) for( int ii = 0; ii < 4; ii++ )
{ {
// Rotate polygon // Rotate polygon
RotatePoint( &corners[ii].x, &corners[ii].y, m_Pos.x, m_Pos.y, m_Orient ); RotatePoint( &corners[ii].x, &corners[ii].y, m_Pos.x, m_Pos.y, m_Orient );
aCornerBuffer.Append( corners[ii] ); aCornerBuffer.Append( corners[ii].x, corners[ii].y );
} }
aCornerBuffer.CloseLastContour();
} }
@ -363,7 +349,7 @@ void TEXTE_PCB::TransformBoundingBoxWithClearanceToPolygon(
* Convert the text shape to a set of polygons (one by segment) * Convert the text shape to a set of polygons (one by segment)
* Used in filling zones calculations and 3D view * Used in filling zones calculations and 3D view
* Circles and arcs are approximated by segments * Circles and arcs are approximated by segments
* aCornerBuffer = CPOLYGONS_LIST to store the polygon corners * aCornerBuffer = SHAPE_POLY_SET to store the polygon corners
* aClearanceValue = the clearance around the text * aClearanceValue = the clearance around the text
* aCircleToSegmentsCount = the number of segments to approximate a circle * aCircleToSegmentsCount = the number of segments to approximate a circle
* aCorrectionFactor = the correction to apply to circles radius to keep * aCorrectionFactor = the correction to apply to circles radius to keep
@ -372,7 +358,7 @@ void TEXTE_PCB::TransformBoundingBoxWithClearanceToPolygon(
*/ */
void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet( void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet(
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const double aCorrectionFactor ) const
@ -428,7 +414,7 @@ void TEXTE_PCB::TransformShapeWithClearanceToPolygonSet(
* clearance when the circle is approxiamted by segment bigger or equal * clearance when the circle is approxiamted by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void DRAWSEGMENT::TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer, void DRAWSEGMENT::TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const double aCorrectionFactor ) const
@ -463,6 +449,8 @@ void DRAWSEGMENT::TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerB
MODULE* module = GetParentModule(); // NULL for items not in footprints MODULE* module = GetParentModule(); // NULL for items not in footprints
double orientation = module ? module->GetOrientation() : 0.0; double orientation = module ? module->GetOrientation() : 0.0;
aCornerBuffer.NewOutline();
// Build the polygon with the actual position and orientation: // Build the polygon with the actual position and orientation:
std::vector< wxPoint> poly; std::vector< wxPoint> poly;
poly = GetPolyPoints(); poly = GetPolyPoints();
@ -498,9 +486,8 @@ void DRAWSEGMENT::TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerB
for( unsigned ii = 0; ii < poly.size(); ii++ ) for( unsigned ii = 0; ii < poly.size(); ii++ )
{ {
CPolyPt corner( poly[ii] ); CPolyPt corner( poly[ii] );
aCornerBuffer.Append( corner ); aCornerBuffer.Append( corner.x, corner.y );
} }
aCornerBuffer.CloseLastContour();
} }
break; break;
@ -525,7 +512,7 @@ void DRAWSEGMENT::TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerB
* clearance when the circle is approximated by segment bigger or equal * clearance when the circle is approximated by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void TRACK:: TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TRACK::TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const double aCorrectionFactor ) const
@ -554,15 +541,14 @@ void TRACK:: TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer
* Convert the pad shape to a closed polygon * Convert the pad shape to a closed polygon
* Used in filling zones calculations and 3D view generation * Used in filling zones calculations and 3D view generation
* Circles and arcs are approximated by segments * Circles and arcs are approximated by segments
* aCornerBuffer = a CPOLYGONS_LIST to store the polygon corners * aCornerBuffer = a SHAPE_POLY_SET to store the polygon corners
* aClearanceValue = the clearance around the pad * aClearanceValue = the clearance around the pad
* aCircleToSegmentsCount = the number of segments to approximate a circle * aCircleToSegmentsCount = the number of segments to approximate a circle
* aCorrectionFactor = the correction to apply to circles radius to keep * aCorrectionFactor = the correction to apply to circles radius to keep
* clearance when the circle is approximated by segment bigger or equal * clearance when the circle is approximated by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
#include <clipper.hpp> void D_PAD:: TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
void D_PAD:: TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const double aCorrectionFactor ) const
@ -615,36 +601,21 @@ void D_PAD:: TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer
wxPoint corners[4]; wxPoint corners[4];
BuildPadPolygon( corners, wxSize( 0, 0 ), angle ); BuildPadPolygon( corners, wxSize( 0, 0 ), angle );
// We are using ClipperLib to inflate the polygon shape, using SHAPE_POLY_SET outline;
// arcs to connect moved segments.
ClipperLib::Path outline; outline.NewOutline();
ClipperLib::Paths shapeWithClearance;
for( int ii = 0; ii < 4; ii++ ) for( int ii = 0; ii < 4; ii++ )
{ {
corners[ii] += PadShapePos; corners[ii] += PadShapePos;
outline << ClipperLib::IntPoint( corners[ii].x, corners[ii].y ); outline.Append( corners[ii].x, corners[ii].y );
} }
ClipperLib::ClipperOffset offset_engine;
// Prepare an offset (inflate) transform, with edges connected by arcs
offset_engine.AddPath( outline, ClipperLib::jtRound, ClipperLib::etClosedPolygon );
// Clipper approximates arcs by segments
// It uses a value called ArcTolerance which is the max error between the arc
// and segments created to approximate this arc
// the number of segm per circle is:
// n = PI / acos(1 - arc_tolerance / (arc radius))
// the arc radius is aClearanceValue
// because arc_tolerance is << aClearanceValue and aClearanceValue >= 0
// n = PI / (arc_tolerance / aClearanceValue )
offset_engine.ArcTolerance = (double)aClearanceValue / 3.14 / aCircleToSegmentsCount;
double rounding_radius = aClearanceValue * aCorrectionFactor; double rounding_radius = aClearanceValue * aCorrectionFactor;
offset_engine.Execute( shapeWithClearance, rounding_radius );
// get new outline (only one polygon is expected) outline.Inflate( (int) rounding_radius, aCircleToSegmentsCount );
aCornerBuffer.ImportFrom( shapeWithClearance );
aCornerBuffer.Append( outline );
} }
break; break;
} }
@ -657,7 +628,7 @@ void D_PAD:: TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer
* Note: for Round and oval pads this function is equivalent to * Note: for Round and oval pads this function is equivalent to
* TransformShapeWithClearanceToPolygon, but not for other shapes * TransformShapeWithClearanceToPolygon, but not for other shapes
*/ */
void D_PAD::BuildPadShapePolygon( CPOLYGONS_LIST& aCornerBuffer, void D_PAD::BuildPadShapePolygon( SHAPE_POLY_SET& aCornerBuffer,
wxSize aInflateValue, int aSegmentsPerCircle, wxSize aInflateValue, int aSegmentsPerCircle,
double aCorrectionFactor ) const double aCorrectionFactor ) const
{ {
@ -674,15 +645,15 @@ void D_PAD::BuildPadShapePolygon( CPOLYGONS_LIST& aCornerBuffer,
case PAD_TRAPEZOID: case PAD_TRAPEZOID:
case PAD_RECT: case PAD_RECT:
aCornerBuffer.NewOutline();
BuildPadPolygon( corners, aInflateValue, m_Orient ); BuildPadPolygon( corners, aInflateValue, m_Orient );
for( int ii = 0; ii < 4; ii++ ) for( int ii = 0; ii < 4; ii++ )
{ {
corners[ii] += PadShapePos; // Shift origin to position corners[ii] += PadShapePos; // Shift origin to position
CPolyPt polypoint( corners[ii].x, corners[ii].y ); aCornerBuffer.Append( corners[ii].x, corners[ii].y );
aCornerBuffer.Append( polypoint );
} }
aCornerBuffer.CloseLastContour();
break; break;
} }
} }
@ -693,7 +664,7 @@ void D_PAD::BuildPadShapePolygon( CPOLYGONS_LIST& aCornerBuffer,
* depending on shape pad hole and orientation * depending on shape pad hole and orientation
* return false if the pad has no hole, true otherwise * return false if the pad has no hole, true otherwise
*/ */
bool D_PAD::BuildPadDrillShapePolygon( CPOLYGONS_LIST& aCornerBuffer, bool D_PAD::BuildPadDrillShapePolygon( SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aSegmentsPerCircle ) const int aInflateValue, int aSegmentsPerCircle ) const
{ {
wxSize drillsize = GetDrillSize(); wxSize drillsize = GetDrillSize();
@ -750,7 +721,7 @@ bool D_PAD::BuildPadDrillShapePolygon( CPOLYGONS_LIST& aCornerBuffer,
* and are used in microwave applications and they *DO NOT* have a thermal relief that * and are used in microwave applications and they *DO NOT* have a thermal relief that
* change the shape by creating stubs and destroy their properties. * change the shape by creating stubs and destroy their properties.
*/ */
void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer, void CreateThermalReliefPadPolygon( SHAPE_POLY_SET& aCornerBuffer,
D_PAD& aPad, D_PAD& aPad,
int aThermalGap, int aThermalGap,
int aCopperThickness, int aCopperThickness,
@ -856,15 +827,16 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
for( unsigned ihole = 0; ihole < 4; ihole++ ) for( unsigned ihole = 0; ihole < 4; ihole++ )
{ {
aCornerBuffer.NewOutline();
for( unsigned ii = 0; ii < corners_buffer.size(); ii++ ) for( unsigned ii = 0; ii < corners_buffer.size(); ii++ )
{ {
corner = corners_buffer[ii]; corner = corners_buffer[ii];
RotatePoint( &corner, th_angle + angle_pad ); // Rotate by segment angle and pad orientation RotatePoint( &corner, th_angle + angle_pad ); // Rotate by segment angle and pad orientation
corner += PadShapePos; corner += PadShapePos;
aCornerBuffer.Append( CPolyPt( corner.x, corner.y ) ); aCornerBuffer.Append( corner.x, corner.y );
} }
aCornerBuffer.CloseLastContour();
th_angle += 900; // Note: th_angle in in 0.1 deg. th_angle += 900; // Note: th_angle in in 0.1 deg.
} }
} }
@ -960,15 +932,15 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
for( int irect = 0; irect < 2; irect++ ) for( int irect = 0; irect < 2; irect++ )
{ {
aCornerBuffer.NewOutline();
for( unsigned ic = 0; ic < corners_buffer.size(); ic++ ) for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
{ {
wxPoint cpos = corners_buffer[ic]; wxPoint cpos = corners_buffer[ic];
RotatePoint( &cpos, angle ); RotatePoint( &cpos, angle );
cpos += PadShapePos; cpos += PadShapePos;
aCornerBuffer.Append( CPolyPt( cpos.x, cpos.y ) ); aCornerBuffer.Append( cpos.x, cpos.y );
} }
aCornerBuffer.CloseLastContour();
angle = AddAngles( angle, 1800 ); // this is calculate hole 3 angle = AddAngles( angle, 1800 ); // this is calculate hole 3
} }
@ -985,15 +957,16 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
for( int irect = 0; irect < 2; irect++ ) for( int irect = 0; irect < 2; irect++ )
{ {
aCornerBuffer.NewOutline();
for( unsigned ic = 0; ic < corners_buffer.size(); ic++ ) for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
{ {
wxPoint cpos = corners_buffer[ic]; wxPoint cpos = corners_buffer[ic];
RotatePoint( &cpos, angle ); RotatePoint( &cpos, angle );
cpos += PadShapePos; cpos += PadShapePos;
aCornerBuffer.Append( CPolyPt( cpos.x, cpos.y ) ); aCornerBuffer.Append( cpos.x, cpos.y );
} }
aCornerBuffer.CloseLastContour();
angle = AddAngles( angle, 1800 ); angle = AddAngles( angle, 1800 );
} }
} }
@ -1057,15 +1030,16 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
for( int irect = 0; irect < 2; irect++ ) for( int irect = 0; irect < 2; irect++ )
{ {
aCornerBuffer.NewOutline();
for( unsigned ic = 0; ic < corners_buffer.size(); ic++ ) for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
{ {
wxPoint cpos = corners_buffer[ic]; wxPoint cpos = corners_buffer[ic];
RotatePoint( &cpos, angle ); // Rotate according to module orientation RotatePoint( &cpos, angle ); // Rotate according to module orientation
cpos += PadShapePos; // Shift origin to position cpos += PadShapePos; // Shift origin to position
aCornerBuffer.Append( CPolyPt( cpos.x, cpos.y ) ); aCornerBuffer.Append( cpos.x, cpos.y );
} }
aCornerBuffer.CloseLastContour();
angle = AddAngles( angle, 1800 ); // this is calculate hole 3 angle = AddAngles( angle, 1800 ); // this is calculate hole 3
} }
@ -1080,15 +1054,16 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
// Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg // Now add corner 4 and 2 (2 is the corner 4 rotated by 180 deg
for( int irect = 0; irect < 2; irect++ ) for( int irect = 0; irect < 2; irect++ )
{ {
aCornerBuffer.NewOutline();
for( unsigned ic = 0; ic < corners_buffer.size(); ic++ ) for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
{ {
wxPoint cpos = corners_buffer[ic]; wxPoint cpos = corners_buffer[ic];
RotatePoint( &cpos, angle ); RotatePoint( &cpos, angle );
cpos += PadShapePos; cpos += PadShapePos;
aCornerBuffer.Append( CPolyPt( cpos.x, cpos.y ) ); aCornerBuffer.Append( cpos.x, cpos.y );
} }
aCornerBuffer.CloseLastContour();
angle = AddAngles( angle, 1800 ); angle = AddAngles( angle, 1800 );
} }
} }
@ -1096,30 +1071,25 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
case PAD_TRAPEZOID: case PAD_TRAPEZOID:
{ {
CPOLYGONS_LIST cbuffer; SHAPE_POLY_SET antipad; // The full antipad area
// We need a length to build the stubs of the thermal reliefs // We need a length to build the stubs of the thermal reliefs
// the value is not very important. The pad bounding box gives a reasonable value // the value is not very important. The pad bounding box gives a reasonable value
EDA_RECT bbox = aPad.GetBoundingBox(); EDA_RECT bbox = aPad.GetBoundingBox();
int stub_len = std::max( bbox.GetWidth(), bbox.GetHeight() ); int stub_len = std::max( bbox.GetWidth(), bbox.GetHeight() );
aPad.TransformShapeWithClearanceToPolygon( cbuffer, aThermalGap, aPad.TransformShapeWithClearanceToPolygon( antipad, aThermalGap,
aCircleToSegmentsCount, aCorrectionFactor ); aCircleToSegmentsCount, aCorrectionFactor );
// We are using ClipperLib to substract stubs to clearance area (antipad area). SHAPE_POLY_SET stub; // A basic stub ( a rectangle)
ClipperLib::Path antipad; // The full antipad area SHAPE_POLY_SET stubs; // the full stubs shape
ClipperLib::Path stub; // A basic stub ( a rectangle) SHAPE_POLY_SET thermalShape; // the holes in copper zone
ClipperLib::Paths stubs; // the full stubs shape
ClipperLib::Paths thermalShape; // the holes in copper zone
// cbuffer is expected to contain only one polygon, which is
// area of the pad + the thermal gap (the antipad)
for( unsigned ii = 0; ii < cbuffer.GetCornersCount(); ii++ )
antipad << ClipperLib::IntPoint( cbuffer.GetPos(ii).x, cbuffer.GetPos(ii).y );
// We now substract the stubs (connections to the copper zone) // We now substract the stubs (connections to the copper zone)
ClipperLib::Clipper clip_engine; //ClipperLib::Clipper clip_engine;
// Prepare a clipping transform // Prepare a clipping transform
clip_engine.AddPath( antipad, ClipperLib::ptSubject, true ); //clip_engine.AddPath( antipad, ClipperLib::ptSubject, true );
// Create stubs and add them to clipper engine // Create stubs and add them to clipper engine
wxPoint stubBuffer[4]; wxPoint stubBuffer[4];
@ -1132,16 +1102,17 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
stubBuffer[3] = stubBuffer[2]; stubBuffer[3] = stubBuffer[2];
stubBuffer[3].y = copper_thickness.y/2; stubBuffer[3].y = copper_thickness.y/2;
stub.NewOutline();
for( unsigned ii = 0; ii < DIM( stubBuffer ); ii++ ) for( unsigned ii = 0; ii < DIM( stubBuffer ); ii++ )
{ {
wxPoint cpos = stubBuffer[ii]; wxPoint cpos = stubBuffer[ii];
RotatePoint( &cpos, aPad.GetOrientation() ); RotatePoint( &cpos, aPad.GetOrientation() );
cpos += PadShapePos; cpos += PadShapePos;
stub << ClipperLib::IntPoint( cpos.x, cpos.y ); stub.Append( cpos.x, cpos.y );
} }
ClipperLib::Clipper stubs_engine; stubs.Append( stub );
stubs_engine.AddPath( stub, ClipperLib::ptSubject, true );
stubBuffer[0].y = stub_len; stubBuffer[0].y = stub_len;
stubBuffer[0].x = copper_thickness.x/2; stubBuffer[0].x = copper_thickness.x/2;
@ -1151,27 +1122,24 @@ void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
stubBuffer[2].y = -stub_len; stubBuffer[2].y = -stub_len;
stubBuffer[3] = stubBuffer[2]; stubBuffer[3] = stubBuffer[2];
stubBuffer[3].x = copper_thickness.x/2; stubBuffer[3].x = copper_thickness.x/2;
stub.clear();
stub.RemoveAllContours();
stub.NewOutline();
for( unsigned ii = 0; ii < DIM( stubBuffer ); ii++ ) for( unsigned ii = 0; ii < DIM( stubBuffer ); ii++ )
{ {
wxPoint cpos = stubBuffer[ii]; wxPoint cpos = stubBuffer[ii];
RotatePoint( &cpos, aPad.GetOrientation() ); RotatePoint( &cpos, aPad.GetOrientation() );
cpos += PadShapePos; cpos += PadShapePos;
stub << ClipperLib::IntPoint( cpos.x, cpos.y ); stub.Append( cpos.x, cpos.y );
} }
stubs_engine.AddPath( stub, ClipperLib::ptClip, true ); stubs.Append( stub );
stubs.Simplify();
// Build the full stubs shape: antipad.BooleanSubtract( stubs );
stubs_engine.Execute( ClipperLib::ctUnion, stubs ); aCornerBuffer.Append( antipad );
// remove stubs to antipad area (i.e. add copper stubs)
clip_engine.AddPath( stubs[0], ClipperLib::ptClip, true );
clip_engine.Execute( ClipperLib::ctDifference, thermalShape );
// put thermal shapes (holes) to list:
aCornerBuffer.ImportFrom( thermalShape );
break; break;
} }

4
pcbnew/class_board.cpp
View File

@ -2741,8 +2741,8 @@ wxString BOARD::GetNextModuleReferenceWithPrefix( const wxString& aPrefix,
* return true if success, false if a contour is not valid * return true if success, false if a contour is not valid
*/ */
#include <specctra.h> #include <specctra.h>
bool BOARD::GetBoardPolygonOutlines( CPOLYGONS_LIST& aOutlines, bool BOARD::GetBoardPolygonOutlines( SHAPE_POLY_SET& aOutlines,
CPOLYGONS_LIST& aHoles, SHAPE_POLY_SET& aHoles,
wxString* aErrorText ) wxString* aErrorText )
{ {
// the SPECCTRA_DB function to extract board outlines: // the SPECCTRA_DB function to extract board outlines:

13
pcbnew/class_board.h
View File

@ -57,7 +57,7 @@ class MSG_PANEL_ITEM;
class NETLIST; class NETLIST;
class REPORTER; class REPORTER;
class RN_DATA; class RN_DATA;
class SHAPE_POLY_SET;
// non-owning container of item candidates when searching for items on the same track. // non-owning container of item candidates when searching for items on the same track.
typedef std::vector< TRACK* > TRACK_PTRS; typedef std::vector< TRACK* > TRACK_PTRS;
@ -600,15 +600,14 @@ public:
* from lines, arcs and circle items on edge cut layer * from lines, arcs and circle items on edge cut layer
* Any closed outline inside the main outline is a hole * Any closed outline inside the main outline is a hole
* All contours should be closed, i.e. have valid vertices to build a closed polygon * All contours should be closed, i.e. have valid vertices to build a closed polygon
* @param aOutlines The CPOLYGONS_LIST to fill in with main outlines. * @param aPoly The SHAPE_POLY_SET to fill in with outlines/holes.
* @param aHoles The empty CPOLYGONS_LIST to fill in with holes, if any.
* @param aErrorText = a wxString reference to display an error message * @param aErrorText = a wxString reference to display an error message
* with the coordinate of the point which creates the error * with the coordinate of the point which creates the error
* (default = NULL , no message returned on error) * (default = NULL , no message returned on error)
* @return true if success, false if a contour is not valid * @return true if success, false if a contour is not valid
*/ */
bool GetBoardPolygonOutlines( CPOLYGONS_LIST& aOutlines, bool GetBoardPolygonOutlines( SHAPE_POLY_SET& aOutlines,
CPOLYGONS_LIST& aHoles, SHAPE_POLY_SET& aHoles,
wxString* aErrorText = NULL ); wxString* aErrorText = NULL );
/** /**
@ -620,9 +619,9 @@ public:
* or 3D viewer * or 3D viewer
* the polygons are not merged. * the polygons are not merged.
* @param aLayer = A copper layer, like B_Cu, etc. * @param aLayer = A copper layer, like B_Cu, etc.
* @param aOutlines The CPOLYGONS_LIST to fill in with items outline. * @param aOutlines The SHAPE_POLY_SET to fill in with items outline.
*/ */
void ConvertBrdLayerToPolygonalContours( LAYER_ID aLayer, CPOLYGONS_LIST& aOutlines ); void ConvertBrdLayerToPolygonalContours( LAYER_ID aLayer, SHAPE_POLY_SET& aOutlines );
/** /**
* Function GetLayerID * Function GetLayerID

2
pcbnew/class_drawsegment.h
View File

@ -231,7 +231,7 @@ public:
* clearance when the circle is approximated by segment bigger or equal * clearance when the circle is approximated by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const; double aCorrectionFactor ) const;

4
pcbnew/class_module.h
View File

@ -336,7 +336,7 @@ public:
* default = false * default = false
*/ */
void TransformPadsShapesWithClearanceToPolygon( LAYER_ID aLayer, void TransformPadsShapesWithClearanceToPolygon( LAYER_ID aLayer,
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aInflateValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor, double aCorrectionFactor,
@ -361,7 +361,7 @@ public:
*/ */
void TransformGraphicShapesWithClearanceToPolygonSet( void TransformGraphicShapesWithClearanceToPolygonSet(
LAYER_ID aLayer, LAYER_ID aLayer,
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aInflateValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ); double aCorrectionFactor );

6
pcbnew/class_pad.h
View File

@ -227,7 +227,7 @@ public:
* clearance when the circle is approximated by segment bigger or equal * clearance when the circle is approximated by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const; double aCorrectionFactor ) const;
@ -324,7 +324,7 @@ public:
* @param aCorrectionFactor = the correction to apply to circles radius to keep * @param aCorrectionFactor = the correction to apply to circles radius to keep
* the pad size when the circle is approximated by segments * the pad size when the circle is approximated by segments
*/ */
void BuildPadShapePolygon( CPOLYGONS_LIST& aCornerBuffer, void BuildPadShapePolygon( SHAPE_POLY_SET& aCornerBuffer,
wxSize aInflateValue, int aSegmentsPerCircle, wxSize aInflateValue, int aSegmentsPerCircle,
double aCorrectionFactor ) const; double aCorrectionFactor ) const;
@ -339,7 +339,7 @@ public:
* (used for round and oblong shapes only(16 to 32 is a good value) * (used for round and oblong shapes only(16 to 32 is a good value)
* @return false if the pad has no hole, true otherwise * @return false if the pad has no hole, true otherwise
*/ */
bool BuildPadDrillShapePolygon( CPOLYGONS_LIST& aCornerBuffer, bool BuildPadDrillShapePolygon( SHAPE_POLY_SET& aCornerBuffer,
int aInflateValue, int aSegmentsPerCircle ) const; int aInflateValue, int aSegmentsPerCircle ) const;
/** /**

4
pcbnew/class_pcb_text.h
View File

@ -111,7 +111,7 @@ public:
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void TransformBoundingBoxWithClearanceToPolygon( void TransformBoundingBoxWithClearanceToPolygon(
CPOLYGONS_LIST& aCornerBuffer, SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue ) const; int aClearanceValue ) const;
/** /**
@ -126,7 +126,7 @@ public:
* clearance when the circle is approximated by segment bigger or equal * clearance when the circle is approximated by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void TransformShapeWithClearanceToPolygonSet( CPOLYGONS_LIST& aCornerBuffer, void TransformShapeWithClearanceToPolygonSet( SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const; double aCorrectionFactor ) const;

2
pcbnew/class_track.h
View File

@ -178,7 +178,7 @@ public:
* clearance when the circle is approximated by segment bigger or equal * clearance when the circle is approximated by segment bigger or equal
* to the real clearance value (usually near from 1.0) * to the real clearance value (usually near from 1.0)
*/ */
void TransformShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
int aClearanceValue, int aClearanceValue,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ) const; double aCorrectionFactor ) const;

111
pcbnew/class_zone.cpp
View File

@ -120,7 +120,7 @@ EDA_ITEM* ZONE_CONTAINER::Clone() const
bool ZONE_CONTAINER::UnFill() bool ZONE_CONTAINER::UnFill()
{ {
bool change = ( m_FilledPolysList.GetCornersCount() > 0 ) || bool change = ( !m_FilledPolysList.IsEmpty() ) ||
( m_FillSegmList.size() > 0 ); ( m_FillSegmList.size() > 0 );
m_FilledPolysList.RemoveAllContours(); m_FilledPolysList.RemoveAllContours();
@ -228,7 +228,7 @@ void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
if( displ_opts->m_DisplayZonesMode == 1 ) // Do not show filled areas if( displ_opts->m_DisplayZonesMode == 1 ) // Do not show filled areas
return; return;
if( m_FilledPolysList.GetCornersCount() == 0 ) // Nothing to draw if( m_FilledPolysList.IsEmpty() ) // Nothing to draw
return; return;
BOARD* brd = GetBoard(); BOARD* brd = GetBoard();
@ -253,35 +253,31 @@ void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
SetAlpha( &color, 150 ); SetAlpha( &color, 150 );
CornersTypeBuffer.clear();
for ( int ic = 0; ic < m_FilledPolysList.OutlineCount(); ic++ )
{
const SHAPE_LINE_CHAIN& path = m_FilledPolysList.COutline( ic );
CornersBuffer.clear(); CornersBuffer.clear();
// Draw all filled areas wxPoint p0;
int imax = m_FilledPolysList.GetCornersCount() - 1;
for( int ic = 0; ic <= imax; ic++ ) for( int j = 0; j < path.PointCount(); j++ )
{ {
const CPolyPt& corner = m_FilledPolysList.GetCorner( ic ); const VECTOR2I& corner = path.CPoint( j );
wxPoint coord( corner.x + offset.x, corner.y + offset.y ); wxPoint coord( corner.x + offset.x, corner.y + offset.y );
CornersBuffer.push_back( coord );
CornersTypeBuffer.push_back( (char) corner.m_flags );
// the last corner of a filled area is found: draw it if( j == 0 )
if( (corner.end_contour) || (ic == imax) ) p0 = coord;
{
/* Draw the current filled area: draw segments outline first CornersBuffer.push_back( coord );
* Curiously, draw segments outline first and after draw filled polygons }
* with outlines thickness = 0 is a faster than
* just draw filled polygons but with outlines thickness = m_ZoneMinThickness CornersBuffer.push_back( p0 );
* So DO NOT use draw filled polygons with outlines having a thickness > 0
* Note: Extra segments ( added to joint holes with external outline) flagged by
* m_flags != 0 are not drawn
* Note not all polygon libraries provide a flag for these extra-segments, therefore
* the m_flags member can be always 0
*/
{
// Draw outlines: // Draw outlines:
if( (m_ZoneMinThickness > 1) || outline_mode ) if( ( m_ZoneMinThickness > 1 ) || outline_mode )
{ {
int ilim = CornersBuffer.size() - 1; int ilim = CornersBuffer.size() - 1;
@ -293,8 +289,6 @@ void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
int y1 = CornersBuffer[ie].y; int y1 = CornersBuffer[ie].y;
// Draw only basic outlines, not extra segments. // Draw only basic outlines, not extra segments.
if( CornersTypeBuffer[ie] == 0 )
{
if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) ) if( !displ_opts->m_DisplayPcbTrackFill || GetState( FORCE_SKETCH ) )
GRCSegm( panel->GetClipBox(), DC, GRCSegm( panel->GetClipBox(), DC,
x0, y0, x1, y1, x0, y0, x1, y1,
@ -305,7 +299,6 @@ void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
m_ZoneMinThickness, color ); m_ZoneMinThickness, color );
} }
} }
}
// Draw areas: // Draw areas:
if( m_FillMode == 0 && !outline_mode ) if( m_FillMode == 0 && !outline_mode )
@ -313,11 +306,6 @@ void ZONE_CONTAINER::DrawFilledArea( EDA_DRAW_PANEL* panel,
true, 0, color, color ); true, 0, color, color );
} }
CornersTypeBuffer.clear();
CornersBuffer.clear();
}
}
if( m_FillMode == 1 && !outline_mode ) // filled with segments if( m_FillMode == 1 && !outline_mode ) // filled with segments
{ {
for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ ) for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ )
@ -576,26 +564,7 @@ int ZONE_CONTAINER::GetClearance( BOARD_CONNECTED_ITEM* aItem ) const
bool ZONE_CONTAINER::HitTestFilledArea( const wxPoint& aRefPos ) const bool ZONE_CONTAINER::HitTestFilledArea( const wxPoint& aRefPos ) const
{ {
unsigned indexstart = 0, indexend; return m_FilledPolysList.Contains( VECTOR2I( aRefPos.x, aRefPos.y ) );
bool inside = false;
for( indexend = 0; indexend < m_FilledPolysList.GetCornersCount(); indexend++ )
{
if( m_FilledPolysList.IsEndContour( indexend ) ) // end of a filled sub-area found
{
if( TestPointInsidePolygon( m_FilledPolysList, indexstart, indexend,
aRefPos.x, aRefPos.y ) )
{
inside = true;
break;
}
// Prepare test of next area which starts after the current index end (if exists)
indexstart = indexend + 1;
}
}
return inside;
} }
@ -674,9 +643,9 @@ void ZONE_CONTAINER::GetMsgPanelInfo( std::vector< MSG_PANEL_ITEM >& aList )
msg.Printf( wxT( "%d" ), (int) m_Poly->m_HatchLines.size() ); msg.Printf( wxT( "%d" ), (int) m_Poly->m_HatchLines.size() );
aList.push_back( MSG_PANEL_ITEM( _( "Hatch Lines" ), msg, BLUE ) ); aList.push_back( MSG_PANEL_ITEM( _( "Hatch Lines" ), msg, BLUE ) );
if( m_FilledPolysList.GetCornersCount() ) if( !m_FilledPolysList.IsEmpty() )
{ {
msg.Printf( wxT( "%d" ), (int) m_FilledPolysList.GetCornersCount() ); msg.Printf( wxT( "%d" ), (int) m_FilledPolysList.TotalVertices() );
aList.push_back( MSG_PANEL_ITEM( _( "Corner Count" ), msg, BLUE ) ); aList.push_back( MSG_PANEL_ITEM( _( "Corner Count" ), msg, BLUE ) );
} }
} }
@ -694,12 +663,7 @@ void ZONE_CONTAINER::Move( const wxPoint& offset )
m_Poly->Hatch(); m_Poly->Hatch();
/* move filled areas: */ m_FilledPolysList.Move( VECTOR2I( offset.x, offset.y ) );
for( unsigned ic = 0; ic < m_FilledPolysList.GetCornersCount(); ic++ )
{
m_FilledPolysList.SetX( ic, m_FilledPolysList.GetX( ic ) + offset.x );
m_FilledPolysList.SetY( ic, m_FilledPolysList.GetY( ic ) + offset.y );
}
for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ ) for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ )
{ {
@ -746,13 +710,8 @@ void ZONE_CONTAINER::Rotate( const wxPoint& centre, double angle )
m_Poly->Hatch(); m_Poly->Hatch();
/* rotate filled areas: */ /* rotate filled areas: */
for( unsigned ic = 0; ic < m_FilledPolysList.GetCornersCount(); ic++ ) for( SHAPE_POLY_SET::ITERATOR ic = m_FilledPolysList.Iterate(); ic; ++ic )
{ RotatePoint( &ic->x, &ic->y, centre.x, centre.y, angle );
pos = m_FilledPolysList.GetPos( ic );
RotatePoint( &pos, centre, angle );
m_FilledPolysList.SetX( ic, pos.x );
m_FilledPolysList.SetY( ic, pos.y );
}
for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ ) for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ )
{ {
@ -779,11 +738,10 @@ void ZONE_CONTAINER::Mirror( const wxPoint& mirror_ref )
m_Poly->Hatch(); m_Poly->Hatch();
/* mirror filled areas: */ for( SHAPE_POLY_SET::ITERATOR ic = m_FilledPolysList.Iterate(); ic; ++ic )
for( unsigned ic = 0; ic < m_FilledPolysList.GetCornersCount(); ic++ )
{ {
int py = mirror_ref.y - m_FilledPolysList.GetY( ic ); int py = mirror_ref.y - ic->y;
m_FilledPolysList.SetY( ic, py + mirror_ref.y ); ic->y = py + mirror_ref.y;
} }
for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ ) for( unsigned ic = 0; ic < m_FillSegmList.size(); ic++ )
@ -897,14 +855,3 @@ wxString ZONE_CONTAINER::GetSelectMenuText() const
return msg; return msg;
} }
/* Copy polygons stored in aKiPolyList to m_FilledPolysList
* The previous m_FilledPolysList contents is replaced.
*/
void ZONE_CONTAINER::CopyPolygonsFromClipperPathsToFilledPolysList(
ClipperLib::Paths& aClipperPolyList )
{
m_FilledPolysList.RemoveAllContours();
m_FilledPolysList.ImportFrom( aClipperPolyList );
}

53
pcbnew/class_zone.h
View File

@ -165,18 +165,6 @@ public:
*/ */
void TestForCopperIslandAndRemoveInsulatedIslands( BOARD* aPcb ); void TestForCopperIslandAndRemoveInsulatedIslands( BOARD* aPcb );
/**
* Function CalculateSubAreaBoundaryBox
* Calculates the bounding box of a a filled area ( list of CPolyPt )
* use m_FilledPolysList as list of CPolyPt (that are the corners of one or more
* polygons or filled areas )
* @return an EDA_RECT as bounding box
* @param aIndexStart = index of the first corner of a polygon (filled area)
* in m_FilledPolysList
* @param aIndexEnd = index of the last corner of a polygon in m_FilledPolysList
*/
EDA_RECT CalculateSubAreaBoundaryBox( int aIndexStart, int aIndexEnd );
/** /**
* Function IsOnCopperLayer * Function IsOnCopperLayer
* @return true if this zone is on a copper layer, false if on a technical layer * @return true if this zone is on a copper layer, false if on a technical layer
@ -271,7 +259,7 @@ public:
* @param aCorrectionFactor = the correction to apply to arcs radius to roughly * @param aCorrectionFactor = the correction to apply to arcs radius to roughly
* keep arc radius when approximated by segments * keep arc radius when approximated by segments
*/ */
void TransformSolidAreasShapesToPolygonSet( CPOLYGONS_LIST& aCornerBuffer, void TransformSolidAreasShapesToPolygonSet( SHAPE_POLY_SET& aCornerBuffer,
int aCircleToSegmentsCount, int aCircleToSegmentsCount,
double aCorrectionFactor ); double aCorrectionFactor );
/** /**
@ -295,32 +283,7 @@ public:
* AddClearanceAreasPolygonsToPolysList() to add holes for pads and tracks * AddClearanceAreasPolygonsToPolysList() to add holes for pads and tracks
* and other items not in net. * and other items not in net.
*/ */
bool BuildFilledSolidAreasPolygons( BOARD* aPcb, CPOLYGONS_LIST* aOutlineBuffer = NULL ); bool BuildFilledSolidAreasPolygons( BOARD* aPcb, SHAPE_POLY_SET* aOutlineBuffer = NULL );
/**
* Function CopyPolygonsFromKiPolygonListToFilledPolysList
* Copy polygons stored in aKiPolyList to m_FilledPolysList
* The previous m_FilledPolysList contents is replaced.
* @param aKiPolyList = a KI_POLYGON_SET containing polygons.
*/
void CopyPolygonsFromKiPolygonListToFilledPolysList( KI_POLYGON_SET& aKiPolyList );
/**
* Function CopyPolygonsFromClipperPathsToFilledPolysList
* Copy polygons stored in aKiPolyList to m_FilledPolysList
* The previous m_FilledPolysList contents is replaced.
* @param aClipperPolyList = a ClipperLib::Paths containing polygons.
*/
void CopyPolygonsFromClipperPathsToFilledPolysList( ClipperLib::Paths& aClipperPolyList );
#if 0 //does not exist in rev 5741.
/**
* Function CopyPolygonsFromFilledPolysListToKiPolygonList
* Copy polygons from m_FilledPolysList to aKiPolyList
* @param aKiPolyList = a KI_POLYGON_SET to fill by polygons.
*/
void CopyPolygonsFromFilledPolysListToKiPolygonList( KI_POLYGON_SET& aKiPolyList );
#endif
/** /**
* Function AddClearanceAreasPolygonsToPolysList * Function AddClearanceAreasPolygonsToPolysList
@ -352,7 +315,7 @@ public:
* false to use aMinClearanceValue only * false to use aMinClearanceValue only
* if both aMinClearanceValue = 0 and aUseNetClearance = false: create the zone outline polygon. * if both aMinClearanceValue = 0 and aUseNetClearance = false: create the zone outline polygon.
*/ */
void TransformOutlinesShapeWithClearanceToPolygon( CPOLYGONS_LIST& aCornerBuffer, void TransformOutlinesShapeWithClearanceToPolygon( SHAPE_POLY_SET& aCornerBuffer,
int aMinClearanceValue, int aMinClearanceValue,
bool aUseNetClearance ); bool aUseNetClearance );
/** /**
@ -510,7 +473,7 @@ public:
* returns a reference to the list of filled polygons. * returns a reference to the list of filled polygons.
* @return Reference to the list of filled polygons. * @return Reference to the list of filled polygons.
*/ */
const CPOLYGONS_LIST& GetFilledPolysList() const const SHAPE_POLY_SET& GetFilledPolysList() const
{ {
return m_FilledPolysList; return m_FilledPolysList;
} }
@ -519,7 +482,7 @@ public:
* Function AddFilledPolysList * Function AddFilledPolysList
* sets the list of filled polygons. * sets the list of filled polygons.
*/ */
void AddFilledPolysList( CPOLYGONS_LIST& aPolysList ) void AddFilledPolysList( SHAPE_POLY_SET& aPolysList )
{ {
m_FilledPolysList = aPolysList; m_FilledPolysList = aPolysList;
} }
@ -548,7 +511,7 @@ public:
void AddPolygon( std::vector< wxPoint >& aPolygon ); void AddPolygon( std::vector< wxPoint >& aPolygon );
void AddFilledPolygon( CPOLYGONS_LIST& aPolygon ) void AddFilledPolygon( SHAPE_POLY_SET& aPolygon )
{ {
m_FilledPolysList.Append( aPolygon ); m_FilledPolysList.Append( aPolygon );
} }
@ -584,7 +547,7 @@ public:
private: private:
void buildFeatureHoleList( BOARD* aPcb, CPOLYGONS_LIST& aFeatures ); void buildFeatureHoleList( BOARD* aPcb, SHAPE_POLY_SET& aFeatures );
CPolyLine* m_Poly; ///< Outline of the zone. CPolyLine* m_Poly; ///< Outline of the zone.
CPolyLine* m_smoothedPoly; // Corner-smoothed version of m_Poly CPolyLine* m_smoothedPoly; // Corner-smoothed version of m_Poly
@ -652,7 +615,7 @@ private:
* connecting "holes" with external main outline. In complex cases an outline * connecting "holes" with external main outline. In complex cases an outline
* described by m_Poly can have many filled areas * described by m_Poly can have many filled areas
*/ */
CPOLYGONS_LIST m_FilledPolysList; SHAPE_POLY_SET m_FilledPolysList;
}; };

81
pcbnew/exporters/export_vrml.cpp
View File

@ -698,11 +698,8 @@ static void export_vrml_drawings( MODEL_VRML& aModel, BOARD* pcb )
// board edges and cutouts // board edges and cutouts
static void export_vrml_board( MODEL_VRML& aModel, BOARD* pcb ) static void export_vrml_board( MODEL_VRML& aModel, BOARD* pcb )
{ {
CPOLYGONS_LIST bufferPcbOutlines; // stores the board main outlines SHAPE_POLY_SET bufferPcbOutlines; // stores the board main outlines
CPOLYGONS_LIST allLayerHoles; // Contains through holes, calculated only once SHAPE_POLY_SET allLayerHoles; // Contains through holes, calculated only once
allLayerHoles.reserve( 20000 );
// Build a polygon from edge cut items // Build a polygon from edge cut items
wxString msg; wxString msg;
@ -715,47 +712,28 @@ static void export_vrml_board( MODEL_VRML& aModel, BOARD* pcb )
} }
double scale = aModel.scale; double scale = aModel.scale;
int i = 0;
int seg; int seg;
// deal with the solid outlines for( int i = 0; i < bufferPcbOutlines.OutlineCount(); i++ )
int nvert = bufferPcbOutlines.GetCornersCount();
while( i < nvert )
{ {
const SHAPE_LINE_CHAIN& outline = bufferPcbOutlines.COutline( i );
seg = aModel.board.NewContour(); seg = aModel.board.NewContour();
if( seg < 0 ) for( int j = 0; j < outline.PointCount(); j++ )
{ {
msg << wxT( "\n\n" ) << aModel.board.AddVertex( seg, (double)outline.CPoint(j).x * scale,
_( "VRML Export Failed:\nCould not add outline to contours." ); -((double)outline.CPoint(j).y * scale ) );
wxMessageBox( msg );
return;
}
while( i < nvert )
{
if( bufferPcbOutlines[i].end_contour )
break;
aModel.board.AddVertex( seg, bufferPcbOutlines[i].x * scale,
-(bufferPcbOutlines[i].y * scale ) );
++i;
} }
aModel.board.EnsureWinding( seg, false ); aModel.board.EnsureWinding( seg, false );
++i;
} }
// deal with the holes for( int i = 0; i < allLayerHoles.OutlineCount(); i++ )
nvert = allLayerHoles.GetCornersCount();
i = 0;
while( i < nvert )
{ {
const SHAPE_LINE_CHAIN& outline = allLayerHoles.COutline( i );
seg = aModel.holes.NewContour(); seg = aModel.holes.NewContour();
if( seg < 0 ) if( seg < 0 )
@ -767,19 +745,14 @@ static void export_vrml_board( MODEL_VRML& aModel, BOARD* pcb )
return; return;
} }
while( i < nvert ) for( int j = 0; j < outline.PointCount(); j++ )
{ {
if( allLayerHoles[i].end_contour ) aModel.holes.AddVertex( seg, (double)outline.CPoint(j).x * scale,
break; -((double)outline.CPoint(j).y * scale ) );
aModel.holes.AddVertex( seg, allLayerHoles[i].x * scale,
-( allLayerHoles[i].y * scale ) );
++i;
} }
aModel.holes.EnsureWinding( seg, true ); aModel.holes.EnsureWinding( seg, true );
++i;
} }
} }
@ -871,9 +844,7 @@ static void export_vrml_tracks( MODEL_VRML& aModel, BOARD* pcb )
static void export_vrml_zones( MODEL_VRML& aModel, BOARD* aPcb ) static void export_vrml_zones( MODEL_VRML& aModel, BOARD* aPcb )
{ {
double scale = aModel.scale; double scale = aModel.scale;
double x, y;
for( int ii = 0; ii < aPcb->GetAreaCount(); ii++ ) for( int ii = 0; ii < aPcb->GetAreaCount(); ii++ )
{ {
@ -890,33 +861,23 @@ static void export_vrml_zones( MODEL_VRML& aModel, BOARD* aPcb )
zone->BuildFilledSolidAreasPolygons( aPcb ); zone->BuildFilledSolidAreasPolygons( aPcb );
} }
const CPOLYGONS_LIST& poly = zone->GetFilledPolysList(); const SHAPE_POLY_SET& poly = zone->GetFilledPolysList();
int nvert = poly.GetCornersCount();
int i = 0;
while( i < nvert ) for( int i = 0; i < poly.OutlineCount(); i++ )
{ {
const SHAPE_LINE_CHAIN& outline = poly.COutline( i );
int seg = vl->NewContour(); int seg = vl->NewContour();
if( seg < 0 ) for( int j = 0; j < outline.PointCount(); j++ )
break;
while( i < nvert )
{ {
x = poly.GetX(i) * scale; if( !vl->AddVertex( seg, (double)outline.CPoint( j ).x * scale,
y = -(poly.GetY(i) * scale); -((double)outline.CPoint( j ).y * scale ) ) )
if( poly.IsEndContour(i) )
break;
if( !vl->AddVertex( seg, x, y ) )
throw( std::runtime_error( vl->GetError() ) ); throw( std::runtime_error( vl->GetError() ) );
++i;
} }
vl->EnsureWinding( seg, false ); vl->EnsureWinding( seg, false );
++i;
} }
} }
} }

14
pcbnew/kicad_plugin.cpp
View File

@ -1617,22 +1617,22 @@ void PCB_IO::format( ZONE_CONTAINER* aZone, int aNestLevel ) const
} }
// Save the PolysList // Save the PolysList
const CPOLYGONS_LIST& fv = aZone->GetFilledPolysList(); const SHAPE_POLY_SET& fv = aZone->GetFilledPolysList();
newLine = 0; newLine = 0;
if( fv.GetCornersCount() ) if( !fv.IsEmpty() )
{ {
m_out->Print( aNestLevel+1, "(filled_polygon\n" ); m_out->Print( aNestLevel+1, "(filled_polygon\n" );
m_out->Print( aNestLevel+2, "(pts\n" ); m_out->Print( aNestLevel+2, "(pts\n" );
for( unsigned it = 0; it < fv.GetCornersCount(); ++it ) for( SHAPE_POLY_SET::CONST_ITERATOR it = fv.CIterate(); it; ++it )
{ {
if( newLine == 0 ) if( newLine == 0 )
m_out->Print( aNestLevel+3, "(xy %s %s)", m_out->Print( aNestLevel+3, "(xy %s %s)",
FMT_IU( fv.GetX( it ) ).c_str(), FMT_IU( fv.GetY( it ) ).c_str() ); FMT_IU( it->x ).c_str(), FMT_IU( it->y ).c_str() );
else else
m_out->Print( 0, " (xy %s %s)", m_out->Print( 0, " (xy %s %s)",
FMT_IU( fv.GetX( it ) ).c_str(), FMT_IU( fv.GetY( it ) ).c_str() ); FMT_IU( it->x ) .c_str(), FMT_IU( it->y ).c_str() );
if( newLine < 4 ) if( newLine < 4 )
{ {
@ -1644,14 +1644,14 @@ void PCB_IO::format( ZONE_CONTAINER* aZone, int aNestLevel ) const
m_out->Print( 0, "\n" ); m_out->Print( 0, "\n" );
} }
if( fv.IsEndContour( it ) ) if( it.IsEndContour() )
{ {
if( newLine != 0 ) if( newLine != 0 )
m_out->Print( 0, "\n" ); m_out->Print( 0, "\n" );
m_out->Print( aNestLevel+2, ")\n" ); m_out->Print( aNestLevel+2, ")\n" );
if( it+1 != fv.GetCornersCount() ) if( !it.IsLastContour() )
{ {
newLine = 0; newLine = 0;
m_out->Print( aNestLevel+1, ")\n" ); m_out->Print( aNestLevel+1, ")\n" );

16
pcbnew/legacy_plugin.cpp
View File

@ -2678,7 +2678,9 @@ void LEGACY_PLUGIN::loadZONE_CONTAINER()
else if( TESTLINE( "$POLYSCORNERS" ) ) else if( TESTLINE( "$POLYSCORNERS" ) )
{ {
// Read the PolysList (polygons used for fill areas in the zone) // Read the PolysList (polygons used for fill areas in the zone)
CPOLYGONS_LIST polysList; SHAPE_POLY_SET polysList;
bool makeNewOutline = true;
while( ( line = READLINE( m_reader ) ) != NULL ) while( ( line = READLINE( m_reader ) ) != NULL )
{ {
@ -2689,11 +2691,17 @@ void LEGACY_PLUGIN::loadZONE_CONTAINER()
BIU x = biuParse( line, &data ); BIU x = biuParse( line, &data );
BIU y = biuParse( data, &data ); BIU y = biuParse( data, &data );
bool end_contour = intParse( data, &data ); // end_countour was a bool when file saved, so '0' or '1' here if( makeNewOutline )
int cornerUtilityFlg = intParse( data ); polysList.NewOutline();
polysList.Append( CPolyPt( x, y, end_contour, cornerUtilityFlg ) ); polysList.Append( x, y );
bool end_contour = intParse( data, &data ); // end_countour was a bool when file saved, so '0' or '1' here
intParse( data ); // skip corner utility flag
makeNewOutline = end_contour;
} }
zc->AddFilledPolysList( polysList ); zc->AddFilledPolysList( polysList );
} }

2
pcbnew/onrightclick.cpp
View File

@ -757,7 +757,7 @@ void PCB_EDIT_FRAME::createPopUpMenuForZones( ZONE_CONTAINER* edge_zone, wxMenu*
AddMenuItem( zones_menu, ID_POPUP_PCB_FILL_ZONE, _( "Fill Zone" ), AddMenuItem( zones_menu, ID_POPUP_PCB_FILL_ZONE, _( "Fill Zone" ),
KiBitmap( fill_zone_xpm ) ); KiBitmap( fill_zone_xpm ) );
if( edge_zone->GetFilledPolysList().GetCornersCount() > 0 ) if( !edge_zone->GetFilledPolysList().IsEmpty() )
{ {
AddMenuItem( zones_menu, ID_POPUP_PCB_REMOVE_FILLED_AREAS_IN_CURRENT_ZONE, AddMenuItem( zones_menu, ID_POPUP_PCB_REMOVE_FILLED_AREAS_IN_CURRENT_ZONE,
_( "Remove Filled Areas in Zone" ), KiBitmap( zone_unfill_xpm ) ); _( "Remove Filled Areas in Zone" ), KiBitmap( zone_unfill_xpm ) );

21
pcbnew/pcb_painter.cpp
View File

@ -885,8 +885,9 @@ void PCB_PAINTER::draw( const ZONE_CONTAINER* aZone )
// Draw the filling // Draw the filling
if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED ) if( displayMode != PCB_RENDER_SETTINGS::DZ_HIDE_FILLED )
{ {
const std::vector<CPolyPt> polyPoints = aZone->GetFilledPolysList().GetList(); const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
if( polyPoints.size() == 0 ) // Nothing to draw
if( polySet.OutlineCount() == 0 ) // Nothing to draw
return; return;
// Set up drawing options // Set up drawing options
@ -904,14 +905,17 @@ void PCB_PAINTER::draw( const ZONE_CONTAINER* aZone )
m_gal->SetIsStroke( true ); m_gal->SetIsStroke( true );
} }
std::vector<CPolyPt>::const_iterator polyIterator; for( int i = 0; i < polySet.OutlineCount(); i++ )
for( polyIterator = polyPoints.begin(); polyIterator != polyPoints.end(); ++polyIterator )
{ {
// Find out all of polygons and then draw them const SHAPE_LINE_CHAIN& outline = polySet.COutline( i );
corners.push_back( VECTOR2D( *polyIterator ) ); // fixme: GAL drawing API that accepts SHAPEs directly (this fiddling with double<>int conversion
// is just a performance hog)
for( int j = 0; j < outline.PointCount(); j++ )
corners.push_back ( (VECTOR2D) outline.CPoint( j ) );
corners.push_back( (VECTOR2D) outline.CPoint( 0 ) );
if( polyIterator->end_contour )
{
if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED ) if( displayMode == PCB_RENDER_SETTINGS::DZ_SHOW_FILLED )
{ {
m_gal->DrawPolygon( corners ); m_gal->DrawPolygon( corners );
@ -925,7 +929,6 @@ void PCB_PAINTER::draw( const ZONE_CONTAINER* aZone )
corners.clear(); corners.clear();
} }
} }
}
} }

9
pcbnew/pcb_parser.cpp
View File

@ -2540,7 +2540,7 @@ ZONE_CONTAINER* PCB_PARSER::parseZONE_CONTAINER() throw( IO_ERROR, PARSE_ERROR )
wxString netnameFromfile; // the zone net name find in file wxString netnameFromfile; // the zone net name find in file
// bigger scope since each filled_polygon is concatenated in here // bigger scope since each filled_polygon is concatenated in here
CPOLYGONS_LIST pts; SHAPE_POLY_SET pts;
std::auto_ptr< ZONE_CONTAINER > zone( new ZONE_CONTAINER( m_board ) ); std::auto_ptr< ZONE_CONTAINER > zone( new ZONE_CONTAINER( m_board ) );
@ -2790,13 +2790,14 @@ ZONE_CONTAINER* PCB_PARSER::parseZONE_CONTAINER() throw( IO_ERROR, PARSE_ERROR )
if( token != T_pts ) if( token != T_pts )
Expecting( T_pts ); Expecting( T_pts );
pts.NewOutline();
for( token = NextTok(); token != T_RIGHT; token = NextTok() ) for( token = NextTok(); token != T_RIGHT; token = NextTok() )
{ {
pts.Append( CPolyPt( parseXY() ) ); pts.Append( parseXY() );
} }
NeedRIGHT(); NeedRIGHT();
pts.CloseLastContour();
} }
break; break;
@ -2841,7 +2842,7 @@ ZONE_CONTAINER* PCB_PARSER::parseZONE_CONTAINER() throw( IO_ERROR, PARSE_ERROR )
zone->Outline()->SetHatch( hatchStyle, hatchPitch, true ); zone->Outline()->SetHatch( hatchStyle, hatchPitch, true );
} }
if( pts.GetCornersCount() ) if( !pts.IsEmpty() )
zone->AddFilledPolysList( pts ); zone->AddFilledPolysList( pts );
// Ensure keepout and non copper zones do not have a net // Ensure keepout and non copper zones do not have a net

104
pcbnew/plot_board_layers.cpp
View File

@ -542,15 +542,14 @@ static const LAYER_ID plot_seq[] = {
/* Plot outlines of copper, for copper layer /* Plot outlines of copper, for copper layer
*/ */
#include "clipper.hpp" void PlotLayerOutlines( BOARD* aBoard, PLOTTER* aPlotter,
void PlotLayerOutlines( BOARD *aBoard, PLOTTER* aPlotter,
LSET aLayerMask, const PCB_PLOT_PARAMS& aPlotOpt ) LSET aLayerMask, const PCB_PLOT_PARAMS& aPlotOpt )
{ {
BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt ); BRDITEMS_PLOTTER itemplotter( aPlotter, aBoard, aPlotOpt );
itemplotter.SetLayerSet( aLayerMask ); itemplotter.SetLayerSet( aLayerMask );
CPOLYGONS_LIST outlines; SHAPE_POLY_SET outlines;
for( LSEQ seq = aLayerMask.Seq( plot_seq, DIM( plot_seq ) ); seq; ++seq ) for( LSEQ seq = aLayerMask.Seq( plot_seq, DIM( plot_seq ) ); seq; ++seq )
{ {
@ -559,52 +558,26 @@ void PlotLayerOutlines( BOARD *aBoard, PLOTTER* aPlotter,
outlines.RemoveAllContours(); outlines.RemoveAllContours();
aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines ); aBoard->ConvertBrdLayerToPolygonalContours( layer, outlines );
// Merge all overlapping polygons. outlines.Simplify();
KI_POLYGON_SET kpolygons;
KI_POLYGON_SET ktmp;
outlines.ExportTo( ktmp );
kpolygons += ktmp;
// Plot outlines // Plot outlines
std::vector< wxPoint > cornerList; std::vector< wxPoint > cornerList;
for( unsigned ii = 0; ii < kpolygons.size(); ii++ )
{
KI_POLYGON polygon = kpolygons[ii];
// polygon contains only one polygon, but it can have holes linked by
// overlapping segments.
// To plot clean outlines, we have to break this polygon into more polygons with
// no overlapping segments, using Clipper, because boost::polygon
// does not allow that
ClipperLib::Path raw_polygon;
ClipperLib::Paths normalized_polygons;
for( unsigned ic = 0; ic < polygon.size(); ic++ )
{
KI_POLY_POINT corner = *(polygon.begin() + ic);
raw_polygon.push_back( ClipperLib::IntPoint( corner.x(), corner.y() ) );
}
ClipperLib::SimplifyPolygon( raw_polygon, normalized_polygons );
// Now we have one or more basic polygons: plot each polygon // Now we have one or more basic polygons: plot each polygon
for( unsigned ii = 0; ii < normalized_polygons.size(); ii++ ) for( int ii = 0; ii < outlines.OutlineCount(); ii++ )
{ {
ClipperLib::Path& polygon = normalized_polygons[ii];
cornerList.clear(); cornerList.clear();
const SHAPE_LINE_CHAIN& path = outlines.COutline( ii );
for( unsigned jj = 0; jj < polygon.size(); jj++ ) for( int jj = 0; jj < path.PointCount(); jj++ )
cornerList.push_back( wxPoint( polygon[jj].X , polygon[jj].Y ) ); cornerList.push_back( wxPoint( path.CPoint( jj ).x , path.CPoint( jj ).x ) );
// Ensure the polygon is closed // Ensure the polygon is closed
if( cornerList[0] != cornerList[cornerList.size()-1] ) if( cornerList[0] != cornerList[cornerList.size() - 1] )
cornerList.push_back( cornerList[0] ); cornerList.push_back( cornerList[0] );
aPlotter->PlotPoly( cornerList, NO_FILL ); aPlotter->PlotPoly( cornerList, NO_FILL );
} }
}
// Plot pad holes // Plot pad holes
if( aPlotOpt.GetDrillMarksType() != PCB_PLOT_PARAMS::NO_DRILL_SHAPE ) if( aPlotOpt.GetDrillMarksType() != PCB_PLOT_PARAMS::NO_DRILL_SHAPE )
@ -704,8 +677,8 @@ void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
// This extra margin is used to merge too close shapes // This extra margin is used to merge too close shapes
// (distance < aMinThickness), and will be removed when creating // (distance < aMinThickness), and will be removed when creating
// the actual shapes // the actual shapes
CPOLYGONS_LIST bufferPolys; // Contains shapes to plot SHAPE_POLY_SET areas; // Contains shapes to plot
CPOLYGONS_LIST initialPolys; // Contains exact shapes to plot SHAPE_POLY_SET initialPolys; // Contains exact shapes to plot
/* calculates the coeff to compensate radius reduction of holes clearance /* calculates the coeff to compensate radius reduction of holes clearance
* due to the segment approx ( 1 /cos( PI/circleToSegmentsCount ) * due to the segment approx ( 1 /cos( PI/circleToSegmentsCount )
@ -722,7 +695,7 @@ void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
circleToSegmentsCount, correction ); circleToSegmentsCount, correction );
// add shapes inflated by aMinThickness/2 // add shapes inflated by aMinThickness/2
module->TransformPadsShapesWithClearanceToPolygon( layer, module->TransformPadsShapesWithClearanceToPolygon( layer,
bufferPolys, inflate, areas, inflate,
circleToSegmentsCount, correction ); circleToSegmentsCount, correction );
} }
@ -754,7 +727,7 @@ void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
if( !( via_set & aLayerMask ).any() ) if( !( via_set & aLayerMask ).any() )
continue; continue;
via->TransformShapeWithClearanceToPolygon( bufferPolys, via_margin, via->TransformShapeWithClearanceToPolygon( areas, via_margin,
circleToSegmentsCount, circleToSegmentsCount,
correction ); correction );
via->TransformShapeWithClearanceToPolygon( initialPolys, via_clearance, via->TransformShapeWithClearanceToPolygon( initialPolys, via_clearance,
@ -771,7 +744,7 @@ void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
if( zone->GetLayer() != layer ) if( zone->GetLayer() != layer )
continue; continue;
zone->TransformOutlinesShapeWithClearanceToPolygon( bufferPolys, zone->TransformOutlinesShapeWithClearanceToPolygon( areas,
inflate, true ); inflate, true );
zone->TransformOutlinesShapeWithClearanceToPolygon( initialPolys, zone->TransformOutlinesShapeWithClearanceToPolygon( initialPolys,
0, true ); 0, true );
@ -788,56 +761,15 @@ void PlotSolderMaskLayer( BOARD *aBoard, PLOTTER* aPlotter,
zone.SetMinThickness( 0 ); // trace polygons only zone.SetMinThickness( 0 ); // trace polygons only
zone.SetLayer ( layer ); zone.SetLayer ( layer );
// Now: areas.BooleanAdd( initialPolys );
// 1 - merge polygons which are intersecting, i.e. remove gaps areas.Inflate( -inflate, circleToSegmentsCount );
// having a thickness < aMinThickness
// 2 - deflate resulting polygons by aMinThickness/2
KI_POLYGON_SET areasToMerge;
bufferPolys.ExportTo( areasToMerge );
KI_POLYGON_SET initialAreas;
initialPolys.ExportTo( initialAreas );
// Merge polygons: because each shape was created with an extra margin
// = aMinThickness/2, shapes too close ( dist < aMinThickness )
// will be merged, because they are overlapping
KI_POLYGON_SET areas;
areas |= areasToMerge; // Populates with merged polygons
// Deflate: remove the extra margin, to create the actual shapes
// Here I am using polygon:resize, because this function creates better shapes
// than deflate algo.
// Use here deflate made by Clipper, because:
// Clipper is (by far) faster and better, event using arcs to deflate shapes
// boost::polygon < 1.56 polygon resize function sometimes crashes when deflating using arcs
// boost::polygon >=1.56 polygon resize function just does not work
// Note also we combine polygons using boost::polygon, which works better than Clipper,
// especially with zones using holes linked to main outlines by overlapping segments
CPOLYGONS_LIST tmp;
tmp.ImportFrom( areas );
// Deflate area using Clipper, better than boost::polygon
ClipperLib::Paths areasDeflate;
tmp.ExportTo( areasDeflate );
// Deflate areas: they will have the right size after deflate
ClipperLib::ClipperOffset offset_engine;
circleToSegmentsCount = 16;
offset_engine.ArcTolerance = (double)inflate / 3.14 / circleToSegmentsCount;
offset_engine.AddPaths( areasDeflate, ClipperLib::jtRound, ClipperLib::etClosedPolygon );
offset_engine.Execute( areasDeflate, -inflate );
// Combine the current areas to initial areas. This is mandatory because // Combine the current areas to initial areas. This is mandatory because
// inflate/deflate transform is not perfect, and we want the initial areas perfectly kept // inflate/deflate transform is not perfect, and we want the initial areas perfectly kept
tmp.RemoveAllContours(); areas.BooleanAdd( initialPolys );
tmp.ImportFrom( areasDeflate ); areas.Fracture();
areas.clear();
tmp.ExportTo( areas );
// Resize slightly changes shapes (the transform is not perfect). zone.AddFilledPolysList( areas );
// So *ensure* initial shapes are kept
areas |= initialAreas;
zone.CopyPolygonsFromKiPolygonListToFilledPolysList( areas );
itemplotter.PlotFilledAreas( &zone ); itemplotter.PlotFilledAreas( &zone );
} }

11
pcbnew/plot_brditems_plotter.cpp
View File

@ -493,10 +493,9 @@ void BRDITEMS_PLOTTER::PlotTextePcb( TEXTE_PCB* pt_texte )
*/ */
void BRDITEMS_PLOTTER::PlotFilledAreas( ZONE_CONTAINER* aZone ) void BRDITEMS_PLOTTER::PlotFilledAreas( ZONE_CONTAINER* aZone )
{ {
const CPOLYGONS_LIST& polysList = aZone->GetFilledPolysList(); const SHAPE_POLY_SET& polysList = aZone->GetFilledPolysList();
unsigned imax = polysList.GetCornersCount();
if( imax == 0 ) // Nothing to draw if( polysList.IsEmpty() )
return; return;
// We need a buffer to store corners coordinates: // We need a buffer to store corners coordinates:
@ -511,12 +510,12 @@ void BRDITEMS_PLOTTER::PlotFilledAreas( ZONE_CONTAINER* aZone )
* *
* in non filled mode the outline is plotted, but not the filling items * in non filled mode the outline is plotted, but not the filling items
*/ */
for( unsigned ic = 0; ic < imax; ic++ ) for( SHAPE_POLY_SET::CONST_ITERATOR ic = polysList.CIterate(); ic; ++ic )
{ {
wxPoint pos = polysList.GetPos( ic ); wxPoint pos( ic->x, ic->y );
cornerList.push_back( pos ); cornerList.push_back( pos );
if( polysList.IsEndContour( ic ) ) // Plot the current filled area outline if( ic.IsEndContour() ) // Plot the current filled area outline
{ {
// First, close the outline // First, close the outline
if( cornerList[0] != cornerList[cornerList.size() - 1] ) if( cornerList[0] != cornerList[cornerList.size() - 1] )

101
pcbnew/ratsnest_data.cpp
View File

@ -44,6 +44,8 @@
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <geometry/shape_poly_set.h>
#include <cassert> #include <cassert>
#include <algorithm> #include <algorithm>
#include <limits> #include <limits>
@ -342,11 +344,16 @@ void RN_NET::clearNode( const RN_NODE_PTR& aNode )
} }
RN_POLY::RN_POLY( const CPolyPt* aBegin, const CPolyPt* aEnd, RN_POLY::RN_POLY( const SHAPE_POLY_SET* aParent,
int aSubpolygonIndex,
RN_LINKS& aConnections, const BOX2I& aBBox ) : RN_LINKS& aConnections, const BOX2I& aBBox ) :
m_begin( aBegin ), m_end( aEnd ), m_bbox( aBBox ) m_subpolygonIndex( aSubpolygonIndex ),
m_bbox( aBBox ),
m_parentPolyset( aParent )
{ {
m_node = aConnections.AddNode( m_begin->x, m_begin->y ); const VECTOR2I& p = aParent->CVertex( aSubpolygonIndex, 0 );
m_node = aConnections.AddNode( p.x, p.y );
// Mark it as not appropriate as a destination of ratsnest edges // Mark it as not appropriate as a destination of ratsnest edges
// (edges coming out from a polygon vertex look weird) // (edges coming out from a polygon vertex look weird)
@ -356,48 +363,9 @@ RN_POLY::RN_POLY( const CPolyPt* aBegin, const CPolyPt* aEnd,
bool RN_POLY::HitTest( const RN_NODE_PTR& aNode ) const bool RN_POLY::HitTest( const RN_NODE_PTR& aNode ) const
{ {
long xt = aNode->GetX(); VECTOR2I p( aNode->GetX(), aNode->GetY() );
long yt = aNode->GetY();
// If the point lies outside the bounding box, there is no point to check it further return m_parentPolyset->Contains( p, m_subpolygonIndex );
if( !m_bbox.Contains( xt, yt ) )
return false;
long xNew, yNew, xOld, yOld, x1, y1, x2, y2;
bool inside = false;
// For the first loop we have to use the last point as the previous point
xOld = m_end->x;
yOld = m_end->y;
for( const CPolyPt* point = m_begin; point <= m_end; ++point )
{
xNew = point->x;
yNew = point->y;
// Swap points if needed, so always x2 >= x1
if( xNew > xOld )
{
x1 = xOld; y1 = yOld;
x2 = xNew; y2 = yNew;
}
else
{
x1 = xNew; y1 = yNew;
x2 = xOld; y2 = yOld;
}
if( ( xNew < xt ) == ( xt <= xOld ) && /* edge "open" at left end */
(double)( yt - y1 ) * (double)( x2 - x1 ) < (double)( y2 - y1 ) * (double)( xt - x1 ) )
{
inside = !inside;
}
xOld = xNew;
yOld = yNew;
}
return inside;
} }
@ -454,51 +422,14 @@ void RN_NET::AddItem( const TRACK* aTrack )
void RN_NET::AddItem( const ZONE_CONTAINER* aZone ) void RN_NET::AddItem( const ZONE_CONTAINER* aZone )
{ {
// Prepare a list of polygons (every zone can contain one or more polygons) // Prepare a list of polygons (every zone can contain one or more polygons)
const std::vector<CPolyPt>& polyPoints = aZone->GetFilledPolysList().GetList(); const SHAPE_POLY_SET& polySet = aZone->GetFilledPolysList();
if( polyPoints.size() == 0 ) for( int i = 0; i < polySet.OutlineCount(); ++i )
return;
// Origin and end of bounding box for a polygon
VECTOR2I origin( polyPoints[0].x, polyPoints[0].y );
VECTOR2I end( polyPoints[0].x, polyPoints[0].y );
unsigned int idxStart = 0;
// Extract polygons from zones
for( unsigned int i = 0; i < polyPoints.size(); ++i )
{ {
const CPolyPt& point = polyPoints[i]; const SHAPE_LINE_CHAIN& path = polySet.COutline( i );
if( point.end_contour ) RN_POLY poly = RN_POLY( &polySet, i, m_links, path.BBox() );
{
RN_POLY poly = RN_POLY( &polyPoints[idxStart], &point,
m_links, BOX2I( origin, end - origin ) );
poly.GetNode()->AddParent( aZone );
m_zones[aZone].m_Polygons.push_back( poly ); m_zones[aZone].m_Polygons.push_back( poly );
idxStart = i + 1;
if( idxStart < polyPoints.size() )
{
origin.x = polyPoints[idxStart].x;
origin.y = polyPoints[idxStart].y;
end.x = polyPoints[idxStart].x;
end.y = polyPoints[idxStart].y;
}
}
else
{
// Determine bounding box
if( point.x < origin.x )
origin.x = point.x;
else if( point.x > end.x )
end.x = point.x;
if( point.y < origin.y )
origin.y = point.y;
else if( point.y > end.y )
end.y = point.y;
}
} }
m_dirty = true; m_dirty = true;

14
pcbnew/ratsnest_data.h
View File

@ -47,7 +47,7 @@ class D_PAD;
class VIA; class VIA;
class TRACK; class TRACK;
class ZONE_CONTAINER; class ZONE_CONTAINER;
class CPolyPt; class SHAPE_POLY_SET;
///> Types of items that are handled by the class ///> Types of items that are handled by the class
enum RN_ITEM_TYPE enum RN_ITEM_TYPE
@ -265,7 +265,8 @@ protected:
class RN_POLY class RN_POLY
{ {
public: public:
RN_POLY( const CPolyPt* aBegin, const CPolyPt* aEnd, RN_POLY( const SHAPE_POLY_SET* aParent,
int aSubpolygonIndex,
RN_LINKS& aConnections, const BOX2I& aBBox ); RN_LINKS& aConnections, const BOX2I& aBBox );
/** /**
@ -287,15 +288,16 @@ public:
bool HitTest( const RN_NODE_PTR& aNode ) const; bool HitTest( const RN_NODE_PTR& aNode ) const;
private: private:
///> Pointer to the first point of polyline bounding the polygon.
const CPolyPt* m_begin;
///> Pointer to the last point of polyline bounding the polygon. ///> Index of the outline in the parent polygon set
const CPolyPt* m_end; int m_subpolygonIndex;
///> Bounding box of the polygon. ///> Bounding box of the polygon.
BOX2I m_bbox; BOX2I m_bbox;
///> Polygon set containing the geometry
const SHAPE_POLY_SET* m_parentPolyset;
///> Node representing a polygon (it has the same coordinates as the first point of its ///> Node representing a polygon (it has the same coordinates as the first point of its
///> bounding polyline. ///> bounding polyline.
RN_NODE_PTR m_node; RN_NODE_PTR m_node;

9
pcbnew/specctra.h
View File

@ -43,6 +43,7 @@ class TRACK;
class VIA; class VIA;
class NETCLASS; class NETCLASS;
class MODULE; class MODULE;
class SHAPE_POLY_SET;
typedef DSN::T DSN_T; typedef DSN::T DSN_T;
@ -3982,16 +3983,16 @@ public:
* any closed outline inside the main outline is a hole * any closed outline inside the main outline is a hole
* All contours should be closed, i.e. have valid vertices to build a closed polygon * All contours should be closed, i.e. have valid vertices to build a closed polygon
* @param aBoard The BOARD to get information from in order to make the outlines. * @param aBoard The BOARD to get information from in order to make the outlines.
* @param aOutlines The CPOLYGONS_LIST to fill in with main outlines. * @param aOutlines The SHAPE_POLY_SET to fill in with main outlines.
* @param aHoles The empty CPOLYGONS_LIST to fill in with holes, if any. * @param aHoles The empty SHAPE_POLY_SET to fill in with holes, if any.
* @param aErrorText = a wxString reference to display an error message * @param aErrorText = a wxString reference to display an error message
* with the coordinate of the point which creates the error * with the coordinate of the point which creates the error
* (default = NULL , no message returned on error) * (default = NULL , no message returned on error)
* @return true if success, false if a contour is not valid * @return true if success, false if a contour is not valid
*/ */
bool GetBoardPolygonOutlines( BOARD* aBoard, bool GetBoardPolygonOutlines( BOARD* aBoard,
CPOLYGONS_LIST& aOutlines, SHAPE_POLY_SET& aOutlines,
CPOLYGONS_LIST& aHoles, SHAPE_POLY_SET& aHoles,
wxString* aErrorText = NULL ); wxString* aErrorText = NULL );
}; };

31
pcbnew/specctra_export.cpp
View File

@ -53,6 +53,8 @@
#include <collectors.h> #include <collectors.h>
#include <geometry/shape_poly_set.h>
#include <specctra.h> #include <specctra.h>
using namespace DSN; using namespace DSN;
@ -1330,8 +1332,8 @@ void SPECCTRA_DB::fillBOUNDARY( BOARD* aBoard, BOUNDARY* boundary )
* All contours should be closed, i.e. valid closed polygon vertices * All contours should be closed, i.e. valid closed polygon vertices
*/ */
bool SPECCTRA_DB::GetBoardPolygonOutlines( BOARD* aBoard, bool SPECCTRA_DB::GetBoardPolygonOutlines( BOARD* aBoard,
CPOLYGONS_LIST& aOutlines, SHAPE_POLY_SET& aOutlines,
CPOLYGONS_LIST& aHoles, SHAPE_POLY_SET& aHoles,
wxString* aErrorText ) wxString* aErrorText )
{ {
bool success = true; bool success = true;
@ -1347,6 +1349,8 @@ bool SPECCTRA_DB::GetBoardPolygonOutlines( BOARD* aBoard,
BOUNDARY* boundary = new BOUNDARY( 0 ); BOUNDARY* boundary = new BOUNDARY( 0 );
pcb->structure->SetBOUNDARY( boundary ); pcb->structure->SetBOUNDARY( boundary );
aOutlines.NewOutline();
try try
{ {
fillBOUNDARY( aBoard, boundary ); fillBOUNDARY( aBoard, boundary );
@ -1357,11 +1361,9 @@ bool SPECCTRA_DB::GetBoardPolygonOutlines( BOARD* aBoard,
{ {
corner.x = buffer[ii] * specctra2UIfactor; corner.x = buffer[ii] * specctra2UIfactor;
corner.y = - buffer[ii+1] * specctra2UIfactor; corner.y = - buffer[ii+1] * specctra2UIfactor;
aOutlines.Append( corner ); aOutlines.Append( corner.x, corner.y );
} }
aOutlines.CloseLastContour();
// Export holes, stored as keepouts polygonal shapes. // Export holes, stored as keepouts polygonal shapes.
// by fillBOUNDARY() // by fillBOUNDARY()
KEEPOUTS& holes = pcb->structure->keepouts; KEEPOUTS& holes = pcb->structure->keepouts;
@ -1371,13 +1373,15 @@ bool SPECCTRA_DB::GetBoardPolygonOutlines( BOARD* aBoard,
KEEPOUT& keepout = *i; KEEPOUT& keepout = *i;
PATH* poly_hole = (PATH*)keepout.shape; PATH* poly_hole = (PATH*)keepout.shape;
POINTS& plist = poly_hole->GetPoints(); POINTS& plist = poly_hole->GetPoints();
aHoles.NewOutline();
for( unsigned ii = 0; ii < plist.size(); ii++ ) for( unsigned ii = 0; ii < plist.size(); ii++ )
{ {
corner.x = plist[ii].x * specctra2UIfactor; corner.x = plist[ii].x * specctra2UIfactor;
corner.y = - plist[ii].y * specctra2UIfactor; corner.y = - plist[ii].y * specctra2UIfactor;
aHoles.Append( corner ); aHoles.Append( corner.x, corner.y );
} }
aHoles.CloseLastContour();
} }
} }
catch( const IO_ERROR& ioe ) catch( const IO_ERROR& ioe )
@ -1397,23 +1401,24 @@ bool SPECCTRA_DB::GetBoardPolygonOutlines( BOARD* aBoard,
if( ( bbbox.GetWidth() ) == 0 || ( bbbox.GetHeight() == 0 ) ) if( ( bbbox.GetWidth() ) == 0 || ( bbbox.GetHeight() == 0 ) )
bbbox.Inflate( Millimeter2iu( 1.0 ) ); bbbox.Inflate( Millimeter2iu( 1.0 ) );
aOutlines.RemoveAllContours();
aOutlines.NewOutline();
corner.x = bbbox.GetOrigin().x; corner.x = bbbox.GetOrigin().x;
corner.y = bbbox.GetOrigin().y; corner.y = bbbox.GetOrigin().y;
aOutlines.Append( corner ); aOutlines.Append( corner.x, corner.y );
corner.x = bbbox.GetOrigin().x; corner.x = bbbox.GetOrigin().x;
corner.y = bbbox.GetEnd().y; corner.y = bbbox.GetEnd().y;
aOutlines.Append( corner ); aOutlines.Append( corner.x, corner.y );
corner.x = bbbox.GetEnd().x; corner.x = bbbox.GetEnd().x;
corner.y = bbbox.GetEnd().y; corner.y = bbbox.GetEnd().y;
aOutlines.Append( corner ); aOutlines.Append( corner.x, corner.y );
corner.x = bbbox.GetEnd().x; corner.x = bbbox.GetEnd().x;
corner.y = bbbox.GetOrigin().y; corner.y = bbbox.GetOrigin().y;
aOutlines.Append( corner ); aOutlines.Append( corner.x, corner.y );
aOutlines.CloseLastContour();
} }
return success; return success;

58
pcbnew/zone_filling_algorithm.cpp
View File

@ -54,7 +54,7 @@
* to add holes for pads and tracks and other items not in net. * to add holes for pads and tracks and other items not in net.
*/ */
bool ZONE_CONTAINER::BuildFilledSolidAreasPolygons( BOARD* aPcb, CPOLYGONS_LIST* aOutlineBuffer ) bool ZONE_CONTAINER::BuildFilledSolidAreasPolygons( BOARD* aPcb, SHAPE_POLY_SET* aOutlineBuffer )
{ {
/* convert outlines + holes to outlines without holes (adding extra segments if necessary) /* convert outlines + holes to outlines without holes (adding extra segments if necessary)
* m_Poly data is expected normalized, i.e. NormalizeAreaOutlines was used after building * m_Poly data is expected normalized, i.e. NormalizeAreaOutlines was used after building
@ -92,7 +92,7 @@ bool ZONE_CONTAINER::BuildFilledSolidAreasPolygons( BOARD* aPcb, CPOLYGONS_LIST*
} }
if( aOutlineBuffer ) if( aOutlineBuffer )
aOutlineBuffer->Append( m_smoothedPoly->m_CornersList ); aOutlineBuffer->Append( ConvertPolyListToPolySet( m_smoothedPoly->m_CornersList ) );
/* For copper layers, we now must add holes in the Polygon list. /* For copper layers, we now must add holes in the Polygon list.
* holes are pads and tracks with their clearance area * holes are pads and tracks with their clearance area
@ -105,15 +105,14 @@ bool ZONE_CONTAINER::BuildFilledSolidAreasPolygons( BOARD* aPcb, CPOLYGONS_LIST*
if( IsOnCopperLayer() ) if( IsOnCopperLayer() )
{ {
if(g_UseOldZoneFillingAlgo)
AddClearanceAreasPolygonsToPolysList( aPcb );
else
AddClearanceAreasPolygonsToPolysList_NG( aPcb ); AddClearanceAreasPolygonsToPolysList_NG( aPcb );
} }
else else
{ {
int margin = m_ZoneMinThickness / 2; int margin = m_ZoneMinThickness / 2;
m_smoothedPoly->m_CornersList.InflateOutline(m_FilledPolysList, -margin, true ); m_FilledPolysList = ConvertPolyListToPolySet( m_smoothedPoly->m_CornersList );
m_FilledPolysList.Inflate( -margin );
m_FilledPolysList.Fracture();
} }
if( m_FillMode ) // if fill mode uses segments, create them: if( m_FillMode ) // if fill mode uses segments, create them:
@ -135,11 +134,9 @@ static bool SortByXValues( const int& a, const int &b )
int ZONE_CONTAINER::FillZoneAreasWithSegments() int ZONE_CONTAINER::FillZoneAreasWithSegments()
{ {
int ics, ice;
int count = 0; int count = 0;
std::vector <int> x_coordinates; std::vector <int> x_coordinates;
bool error = false; bool error = false;
int istart, iend; // index of the starting and the endif corner of one filled area in m_FilledPolysList
int margin = m_ZoneMinThickness * 2 / 10; int margin = m_ZoneMinThickness * 2 / 10;
int minwidth = Mils2iu( 2 ); int minwidth = Mils2iu( 2 );
margin = std::max ( minwidth, margin ); margin = std::max ( minwidth, margin );
@ -148,16 +145,11 @@ int ZONE_CONTAINER::FillZoneAreasWithSegments()
// Read all filled areas in m_FilledPolysList // Read all filled areas in m_FilledPolysList
m_FillSegmList.clear(); m_FillSegmList.clear();
istart = 0;
int end_list = m_FilledPolysList.GetCornersCount() - 1;
for( int ic = 0; ic <= end_list; ic++ ) for ( int index = 0; index < m_FilledPolysList.OutlineCount(); index++ )
{ {
CPolyPt* corner = &m_FilledPolysList[ic]; const SHAPE_LINE_CHAIN& outline = m_FilledPolysList.COutline( index );
if ( corner->end_contour || ( ic == end_list ) ) const BOX2I& rect = outline.BBox();
{
iend = ic;
EDA_RECT rect = CalculateSubAreaBoundaryBox( istart, iend );
// Calculate the y limits of the zone // Calculate the y limits of the zone
for( int refy = rect.GetY(), endy = rect.GetBottom(); refy < endy; refy += step ) for( int refy = rect.GetY(), endy = rect.GetBottom(); refy < endy; refy += step )
@ -165,19 +157,16 @@ int ZONE_CONTAINER::FillZoneAreasWithSegments()
// find all intersection points of an infinite line with polyline sides // find all intersection points of an infinite line with polyline sides
x_coordinates.clear(); x_coordinates.clear();
for( ics = istart, ice = iend; ics <= iend; ice = ics, ics++ ) for( int v = 0; v < outline.PointCount(); v++ )
{ {
if( m_FilledPolysList[ice].m_flags )
continue;
int seg_startX = m_FilledPolysList[ics].x;
int seg_startY = m_FilledPolysList[ics].y;
int seg_endX = m_FilledPolysList[ice].x;
int seg_endY = m_FilledPolysList[ice].y;
int seg_startX = outline.CPoint( v ).x;
int seg_startY = outline.CPoint( v ).y;
int seg_endX = outline.CPoint( v + 1 ).x;
int seg_endY = outline.CPoint( v + 1 ).y;
/* Trivial cases: skip if ref above or below the segment to test */ /* Trivial cases: skip if ref above or below the segment to test */
if( ( seg_startY > refy ) && (seg_endY > refy ) ) if( ( seg_startY > refy ) && ( seg_endY > refy ) )
continue; continue;
// segment below ref point, or its Y end pos on Y coordinate ref point: skip // segment below ref point, or its Y end pos on Y coordinate ref point: skip
@ -190,6 +179,7 @@ int ZONE_CONTAINER::FillZoneAreasWithSegments()
// calculate the x position of the intersection of this segment and the // calculate the x position of the intersection of this segment and the
// infinite line this is more easier if we move the X,Y axis origin to // infinite line this is more easier if we move the X,Y axis origin to
// the segment start point: // the segment start point:
seg_endX -= seg_startX; seg_endX -= seg_startX;
seg_endY -= seg_startY; seg_endY -= seg_startY;
double newrefy = (double) ( refy - seg_startY ); double newrefy = (double) ( refy - seg_startY );
@ -219,12 +209,12 @@ int ZONE_CONTAINER::FillZoneAreasWithSegments()
// Create segments // Create segments
if ( !error && ( x_coordinates.size() & 1 ) != 0 ) if( !error && ( x_coordinates.size() & 1 ) != 0 )
{ // An even number of coordinates is expected, because a segment has 2 ends. { // An even number of coordinates is expected, because a segment has 2 ends.
// An if this algorithm always works, it must always find an even count. // An if this algorithm always works, it must always find an even count.
wxString msg = wxT("Fill Zone: odd number of points at y = "); wxString msg = wxT( "Fill Zone: odd number of points at y = " );
msg << refy; msg << refy;
wxMessageBox(msg ); wxMessageBox( msg );
error = true; error = true;
} }
@ -233,13 +223,13 @@ int ZONE_CONTAINER::FillZoneAreasWithSegments()
int iimax = x_coordinates.size() - 1; int iimax = x_coordinates.size() - 1;
for( int ii = 0; ii < iimax; ii +=2 ) for( int ii = 0; ii < iimax; ii += 2 )
{ {
wxPoint seg_start, seg_end; wxPoint seg_start, seg_end;
count++; count++;
seg_start.x = x_coordinates[ii]; seg_start.x = x_coordinates[ii];
seg_start.y = refy; seg_start.y = refy;
seg_end.x = x_coordinates[ii+1]; seg_end.x = x_coordinates[ii + 1];
seg_end.y = refy; seg_end.y = refy;
SEGMENT segment( seg_start, seg_end ); SEGMENT segment( seg_start, seg_end );
m_FillSegmList.push_back( segment ); m_FillSegmList.push_back( segment );
@ -248,13 +238,7 @@ int ZONE_CONTAINER::FillZoneAreasWithSegments()
if( error ) if( error )
break; break;
}
istart = iend + 1; // istart points the first corner of the next area
} // End find one end of outline
if( error )
break;
} // End examine all areas
if( !error ) if( !error )
m_IsFilled = true; m_IsFilled = true;

247
pcbnew/zones_convert_brd_items_to_polygons_with_Boost.cpp
View File

@ -48,7 +48,6 @@
#include <sstream> #include <sstream>
#include <fctsys.h> #include <fctsys.h>
#include <polygons_defs.h>
#include <wxPcbStruct.h> #include <wxPcbStruct.h>
#include <trigo.h> #include <trigo.h>
@ -70,7 +69,7 @@
#include <boost/foreach.hpp> #include <boost/foreach.hpp>
extern void BuildUnconnectedThermalStubsPolygonList( CPOLYGONS_LIST& aCornerBuffer, extern void BuildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCornerBuffer,
BOARD* aPcb, ZONE_CONTAINER* aZone, BOARD* aPcb, ZONE_CONTAINER* aZone,
double aArcCorrection, double aArcCorrection,
double aRoundPadThermalRotation); double aRoundPadThermalRotation);
@ -78,7 +77,7 @@ extern void BuildUnconnectedThermalStubsPolygonList( CPOLYGONS_LIST& aCornerBuff
extern void Test_For_Copper_Island_And_Remove( BOARD* aPcb, extern void Test_For_Copper_Island_And_Remove( BOARD* aPcb,
ZONE_CONTAINER* aZone_container ); ZONE_CONTAINER* aZone_container );
extern void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer, extern void CreateThermalReliefPadPolygon( SHAPE_POLY_SET& aCornerBuffer,
D_PAD& aPad, D_PAD& aPad,
int aThermalGap, int aThermalGap,
int aCopperThickness, int aCopperThickness,
@ -90,7 +89,7 @@ extern void CreateThermalReliefPadPolygon( CPOLYGONS_LIST& aCornerBuffer,
// Local Variables: // Local Variables:
static double s_thermalRot = 450; // angle of stubs in thermal reliefs for round pads static double s_thermalRot = 450; // angle of stubs in thermal reliefs for round pads
void ZONE_CONTAINER::buildFeatureHoleList( BOARD* aPcb, CPOLYGONS_LIST& aFeatures ) void ZONE_CONTAINER::buildFeatureHoleList( BOARD* aPcb, SHAPE_POLY_SET& aFeatures )
{ {
int segsPerCircle; int segsPerCircle;
double correctionFactor; double correctionFactor;
@ -368,83 +367,6 @@ void ZONE_CONTAINER::buildFeatureHoleList( BOARD* aPcb, CPOLYGONS_LIST& aFeature
} }
static const SHAPE_POLY_SET convertPolyListToPolySet(const CPOLYGONS_LIST& aList)
{
SHAPE_POLY_SET rv;
unsigned corners_count = aList.GetCornersCount();
// Enter main outline: this is the first contour
unsigned ic = 0;
if(!corners_count)
return rv;
while( ic < corners_count )
{
rv.NewOutline( );
while( ic < corners_count )
{
rv.AppendVertex( aList.GetX(ic), aList.GetY(ic) );
if( aList.IsEndContour( ic ) )
break;
ic++;
}
ic++;
}
return rv;
}
static const CPOLYGONS_LIST convertPolySetToPolyList(const SHAPE_POLY_SET& aPolyset)
{
CPOLYGONS_LIST list;
CPolyPt corner, firstCorner;
for( int ii = 0; ii < aPolyset.OutlineCount(); ii++ )
{
for( int jj = 0; jj < aPolyset.VertexCount(ii); jj++ )
{
VECTOR2I v = aPolyset.GetVertex( jj, ii );
corner.x = v.x;
corner.y = v.y;
corner.end_contour = false;
if(!jj)
firstCorner = corner;
list.AddCorner( corner );
}
firstCorner.end_contour = true;
list.AddCorner( firstCorner );
}
return list;
}
static const SHAPE_POLY_SET convertBoostToPolySet ( const KI_POLYGON_SET& aSet )
{
SHAPE_POLY_SET rv;
BOOST_FOREACH ( const KI_POLYGON &poly, aSet )
{
rv.NewOutline();
for ( KI_POLYGON::iterator_type corner = poly.begin(); corner != poly.end(); ++ corner )
{
rv.AppendVertex ( corner->x(), corner->y() );
}
}
return rv;
}
/** /**
* Function AddClearanceAreasPolygonsToPolysList * Function AddClearanceAreasPolygonsToPolysList
@ -502,16 +424,18 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList_NG( BOARD* aPcb )
if(g_DumpZonesWhenFilling) if(g_DumpZonesWhenFilling)
dumper->BeginGroup("clipper-zone"); dumper->BeginGroup("clipper-zone");
m_smoothedPoly->m_CornersList.InflateOutline( tmp, -outline_half_thickness, true ); SHAPE_POLY_SET solidAreas = ConvertPolyListToPolySet( m_smoothedPoly->m_CornersList );
SHAPE_POLY_SET solidAreas = convertPolyListToPolySet( tmp );
solidAreas.Inflate( -outline_half_thickness );
solidAreas.Simplify();
SHAPE_POLY_SET holes;
if(g_DumpZonesWhenFilling) if(g_DumpZonesWhenFilling)
dumper->Write( &solidAreas, "solid-areas" ); dumper->Write( &solidAreas, "solid-areas" );
tmp.RemoveAllContours(); tmp.RemoveAllContours();
buildFeatureHoleList( aPcb, tmp ); buildFeatureHoleList( aPcb, holes );
SHAPE_POLY_SET holes = convertPolyListToPolySet( tmp );
if(g_DumpZonesWhenFilling) if(g_DumpZonesWhenFilling)
dumper->Write( &holes, "feature-holes" ); dumper->Write( &holes, "feature-holes" );
@ -521,61 +445,49 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList_NG( BOARD* aPcb )
if (g_DumpZonesWhenFilling) if (g_DumpZonesWhenFilling)
dumper->Write( &holes, "feature-holes-postsimplify" ); dumper->Write( &holes, "feature-holes-postsimplify" );
solidAreas.Subtract( holes ); solidAreas.BooleanSubtract( holes );
if (g_DumpZonesWhenFilling) if (g_DumpZonesWhenFilling)
dumper->Write( &solidAreas, "solid-areas-minus-holes" ); dumper->Write( &solidAreas, "solid-areas-minus-holes" );
m_FilledPolysList.RemoveAllContours();
SHAPE_POLY_SET fractured = solidAreas; SHAPE_POLY_SET fractured = solidAreas;
fractured.Fracture(); fractured.Fracture();
if (g_DumpZonesWhenFilling) if (g_DumpZonesWhenFilling)
dumper->Write( &fractured, "fractured" ); dumper->Write( &fractured, "fractured" );
m_FilledPolysList = convertPolySetToPolyList( fractured ); m_FilledPolysList = fractured;
if (g_DumpZonesWhenFilling)
{
SHAPE_POLY_SET dupa = convertPolyListToPolySet ( m_FilledPolysList );
dumper->Write( &dupa, "verify-conv" );
}
// Remove insulated islands: // Remove insulated islands:
if( GetNetCode() > 0 ) if( GetNetCode() > 0 )
TestForCopperIslandAndRemoveInsulatedIslands( aPcb ); TestForCopperIslandAndRemoveInsulatedIslands( aPcb );
tmp.RemoveAllContours(); SHAPE_POLY_SET thermalHoles;
// Test thermal stubs connections and add polygons to remove unconnected stubs. // Test thermal stubs connections and add polygons to remove unconnected stubs.
// (this is a refinement for thermal relief shapes) // (this is a refinement for thermal relief shapes)
if( GetNetCode() > 0 ) if( GetNetCode() > 0 )
BuildUnconnectedThermalStubsPolygonList( tmp, aPcb, this, BuildUnconnectedThermalStubsPolygonList( thermalHoles, aPcb, this,
correctionFactor, s_thermalRot ); correctionFactor, s_thermalRot );
// remove copper areas corresponding to not connected stubs // remove copper areas corresponding to not connected stubs
if( tmp.GetCornersCount() ) if( !thermalHoles.IsEmpty() )
{ {
SHAPE_POLY_SET thermalHoles = convertPolyListToPolySet ( tmp );
thermalHoles.Simplify(); thermalHoles.Simplify();
// Remove unconnected stubs // Remove unconnected stubs
solidAreas.Subtract ( thermalHoles ); solidAreas.BooleanSubtract( thermalHoles );
if (g_DumpZonesWhenFilling)
dumper->Write ( &thermalHoles, "thermal-holes" );
if( g_DumpZonesWhenFilling )
dumper->Write( &thermalHoles, "thermal-holes" );
// put these areas in m_FilledPolysList // put these areas in m_FilledPolysList
m_FilledPolysList.RemoveAllContours();
SHAPE_POLY_SET fractured = solidAreas; SHAPE_POLY_SET fractured = solidAreas;
fractured.Fracture(); fractured.Fracture();
if (g_DumpZonesWhenFilling) if( g_DumpZonesWhenFilling )
dumper->Write ( &fractured, "fractured" ); dumper->Write ( &fractured, "fractured" );
m_FilledPolysList = convertPolySetToPolyList( fractured ); m_FilledPolysList = fractured;
if( GetNetCode() > 0 ) if( GetNetCode() > 0 )
TestForCopperIslandAndRemoveInsulatedIslands( aPcb ); TestForCopperIslandAndRemoveInsulatedIslands( aPcb );
@ -587,121 +499,4 @@ void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList_NG( BOARD* aPcb )
void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList( BOARD* aPcb ) void ZONE_CONTAINER::AddClearanceAreasPolygonsToPolysList( BOARD* aPcb )
{ {
int segsPerCircle;
double correctionFactor;
std::auto_ptr<SHAPE_FILE_IO> dumper( new SHAPE_FILE_IO( "zones_dump.txt", true ) );
if(g_DumpZonesWhenFilling)
dumper->BeginGroup("boost-zone");
// Set the number of segments in arc approximations
if( m_ArcToSegmentsCount == ARC_APPROX_SEGMENTS_COUNT_HIGHT_DEF )
segsPerCircle = ARC_APPROX_SEGMENTS_COUNT_HIGHT_DEF;
else
segsPerCircle = ARC_APPROX_SEGMENTS_COUNT_LOW_DEF;
/* calculates the coeff to compensate radius reduction of holes clearance
* due to the segment approx.
* For a circle the min radius is radius * cos( 2PI / s_CircleToSegmentsCount / 2)
* s_Correction is 1 /cos( PI/s_CircleToSegmentsCount )
*/
correctionFactor = 1.0 / cos( M_PI / (double) segsPerCircle );
// this is a place to store holes (i.e. tracks, pads ... areas as polygons outlines)
// static to avoid unnecessary memory allocation when filling many zones.
CPOLYGONS_LIST cornerBufferPolysToSubstract;
// This KI_POLYGON_SET is the area(s) to fill, with m_ZoneMinThickness/2
KI_POLYGON_SET polyset_zone_solid_areas;
int outline_half_thickness = m_ZoneMinThickness / 2;
/* First, creates the main polygon (i.e. the filled area using only one outline)
* to reserve a m_ZoneMinThickness/2 margin around the outlines and holes
* this margin is the room to redraw outlines with segments having a width set to
* m_ZoneMinThickness
* so m_ZoneMinThickness is the min thickness of the filled zones areas
* the main polygon is stored in polyset_zone_solid_areas
*/
CPOLYGONS_LIST tmp;
m_smoothedPoly->m_CornersList.InflateOutline( tmp, -outline_half_thickness, true );
tmp.ExportTo( polyset_zone_solid_areas );
if( polyset_zone_solid_areas.size() == 0 )
return;
if (g_DumpZonesWhenFilling)
dumper->Write ( convertBoostToPolySet( polyset_zone_solid_areas ), "solid-areas" );
buildFeatureHoleList( aPcb, cornerBufferPolysToSubstract );
// cornerBufferPolysToSubstract contains polygons to substract.
// polyset_zone_solid_areas contains the main filled area
// Calculate now actual solid areas
if( cornerBufferPolysToSubstract.GetCornersCount() > 0 )
{
KI_POLYGON_SET polyset_holes;
cornerBufferPolysToSubstract.ExportTo( polyset_holes );
if (g_DumpZonesWhenFilling)
dumper->Write ( convertBoostToPolySet( polyset_holes ), "feature-holes" );
// Remove holes from initial area.:
polyset_zone_solid_areas -= polyset_holes;
}
// put solid areas in m_FilledPolysList:
m_FilledPolysList.RemoveAllContours();
CopyPolygonsFromKiPolygonListToFilledPolysList( polyset_zone_solid_areas );
// Remove insulated islands:
if( GetNetCode() > 0 )
TestForCopperIslandAndRemoveInsulatedIslands( aPcb );
// Now we remove all unused thermal stubs.
cornerBufferPolysToSubstract.RemoveAllContours();
// Test thermal stubs connections and add polygons to remove unconnected stubs.
// (this is a refinement for thermal relief shapes)
if( GetNetCode() > 0 )
BuildUnconnectedThermalStubsPolygonList( cornerBufferPolysToSubstract, aPcb, this,
correctionFactor, s_thermalRot );
// remove copper areas corresponding to not connected stubs
if( cornerBufferPolysToSubstract.GetCornersCount() )
{
KI_POLYGON_SET polyset_holes;
cornerBufferPolysToSubstract.ExportTo( polyset_holes );
if (g_DumpZonesWhenFilling)
dumper->Write ( convertBoostToPolySet( polyset_holes ), "thermal-holes" );
// Remove unconnected stubs
polyset_zone_solid_areas -= polyset_holes;
// put these areas in m_FilledPolysList
m_FilledPolysList.RemoveAllContours();
CopyPolygonsFromKiPolygonListToFilledPolysList( polyset_zone_solid_areas );
if( GetNetCode() > 0 )
TestForCopperIslandAndRemoveInsulatedIslands( aPcb );
}
if (g_DumpZonesWhenFilling)
dumper->Write ( convertBoostToPolySet( polyset_zone_solid_areas ), "complete" );
cornerBufferPolysToSubstract.RemoveAllContours();
}
void ZONE_CONTAINER::CopyPolygonsFromKiPolygonListToFilledPolysList( KI_POLYGON_SET& aKiPolyList )
{
m_FilledPolysList.RemoveAllContours();
m_FilledPolysList.ImportFrom( aKiPolyList );
} }

23
pcbnew/zones_convert_to_polygons_aux_functions.cpp
View File

@ -27,7 +27,6 @@
*/ */
#include <fctsys.h> #include <fctsys.h>
#include <polygons_defs.h>
#include <PolyLine.h> #include <PolyLine.h>
#include <wxPcbStruct.h> #include <wxPcbStruct.h>
#include <trigo.h> #include <trigo.h>
@ -48,11 +47,10 @@
* false to create the outline polygon. * false to create the outline polygon.
*/ */
void ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon( void ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(
CPOLYGONS_LIST& aCornerBuffer, int aMinClearanceValue, bool aUseNetClearance ) SHAPE_POLY_SET& aCornerBuffer, int aMinClearanceValue, bool aUseNetClearance )
{ {
// Creates the zone outline polygon (with linked holes if any) // Creates the zone outline polygon (with linked holes if any)
CPOLYGONS_LIST zoneOutline; BuildFilledSolidAreasPolygons( NULL, &aCornerBuffer );
BuildFilledSolidAreasPolygons( NULL, &zoneOutline );
// add clearance to outline // add clearance to outline
int clearance = aMinClearanceValue; int clearance = aMinClearanceValue;
@ -67,9 +65,9 @@ void ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(
// Calculate the polygon with clearance // Calculate the polygon with clearance
// holes are linked to the main outline, so only one polygon is created. // holes are linked to the main outline, so only one polygon is created.
if( clearance ) if( clearance )
zoneOutline.InflateOutline( aCornerBuffer, clearance, true ); aCornerBuffer.Inflate( clearance );
else
ConvertPolysListWithHolesToOnePolygon( zoneOutline, aCornerBuffer ); aCornerBuffer.Fracture( );
} }
@ -78,14 +76,14 @@ void ZONE_CONTAINER::TransformOutlinesShapeWithClearanceToPolygon(
* Function BuildUnconnectedThermalStubsPolygonList * Function BuildUnconnectedThermalStubsPolygonList
* Creates a set of polygons corresponding to stubs created by thermal shapes on pads * Creates a set of polygons corresponding to stubs created by thermal shapes on pads
* which are not connected to a zone (dangling bridges) * which are not connected to a zone (dangling bridges)
* @param aCornerBuffer = a CPOLYGONS_LIST where to store polygons * @param aCornerBuffer = a SHAPE_POLY_SET where to store polygons
* @param aPcb = the board. * @param aPcb = the board.
* @param aZone = a pointer to the ZONE_CONTAINER to examine. * @param aZone = a pointer to the ZONE_CONTAINER to examine.
* @param aArcCorrection = a pointer to the ZONE_CONTAINER to examine. * @param aArcCorrection = a pointer to the ZONE_CONTAINER to examine.
* @param aRoundPadThermalRotation = the rotation in 1.0 degree for thermal stubs in round pads * @param aRoundPadThermalRotation = the rotation in 1.0 degree for thermal stubs in round pads
*/ */
void BuildUnconnectedThermalStubsPolygonList( CPOLYGONS_LIST& aCornerBuffer, void BuildUnconnectedThermalStubsPolygonList( SHAPE_POLY_SET& aCornerBuffer,
BOARD* aPcb, BOARD* aPcb,
ZONE_CONTAINER* aZone, ZONE_CONTAINER* aZone,
double aArcCorrection, double aArcCorrection,
@ -235,6 +233,7 @@ void BuildUnconnectedThermalStubsPolygonList( CPOLYGONS_LIST& aCornerBuffer,
break; break;
} }
aCornerBuffer.NewOutline();
// add computed polygon to list // add computed polygon to list
for( unsigned ic = 0; ic < corners_buffer.size(); ic++ ) for( unsigned ic = 0; ic < corners_buffer.size(); ic++ )
@ -242,11 +241,7 @@ void BuildUnconnectedThermalStubsPolygonList( CPOLYGONS_LIST& aCornerBuffer,
wxPoint cpos = corners_buffer[ic]; wxPoint cpos = corners_buffer[ic];
RotatePoint( &cpos, fAngle ); // Rotate according to module orientation RotatePoint( &cpos, fAngle ); // Rotate according to module orientation
cpos += pad->ShapePos(); // Shift origin to position cpos += pad->ShapePos(); // Shift origin to position
CPolyPt corner; aCornerBuffer.Append( cpos.x, cpos.y );
corner.x = cpos.x;
corner.y = cpos.y;
corner.end_contour = ( ic < (corners_buffer.size() - 1) ) ? false : true;
aCornerBuffer.Append( corner );
} }
} }
} }

61
pcbnew/zones_polygons_insulated_copper_islands.cpp
View File

@ -40,7 +40,7 @@
void ZONE_CONTAINER::TestForCopperIslandAndRemoveInsulatedIslands( BOARD* aPcb ) void ZONE_CONTAINER::TestForCopperIslandAndRemoveInsulatedIslands( BOARD* aPcb )
{ {
if( m_FilledPolysList.GetCornersCount() == 0 ) if( m_FilledPolysList.IsEmpty() )
return; return;
// Build a list of points connected to the net: // Build a list of points connected to the net:
@ -76,74 +76,27 @@ void ZONE_CONTAINER::TestForCopperIslandAndRemoveInsulatedIslands( BOARD* aPcb )
} }
// test if a point is inside // test if a point is inside
unsigned indexstart = 0, indexend;
bool connected = false;
for( indexend = 0; indexend < m_FilledPolysList.GetCornersCount(); indexend++ ) for( int outline = 0; outline < m_FilledPolysList.OutlineCount(); outline++ )
{ {
if( m_FilledPolysList[indexend].end_contour ) // end of a filled sub-area found bool connected = false;
{
EDA_RECT bbox = CalculateSubAreaBoundaryBox( indexstart, indexend );
for( unsigned ic = 0; ic < listPointsCandidates.size(); ic++ ) for( unsigned ic = 0; ic < listPointsCandidates.size(); ic++ )
{ {
// test if this area is connected to a board item: // test if this area is connected to a board item:
wxPoint pos = listPointsCandidates[ic]; wxPoint pos = listPointsCandidates[ic];
if( !bbox.Contains( pos ) ) if( m_FilledPolysList.Contains( VECTOR2I( pos.x, pos.y ), outline ) )
continue;
if( TestPointInsidePolygon( m_FilledPolysList, indexstart, indexend,
pos.x, pos.y ) )
{ {
connected = true; connected = true;
break; break;
} }
} }
if( connected ) // this polygon is connected: analyse next polygon if( !connected ) // this polygon is connected: analyse next polygon
{ {
indexstart = indexend + 1; // indexstart points the first point of the next polygon m_FilledPolysList.DeletePolygon( outline );
connected = false; outline--;
}
else // Not connected: remove this polygon
{
m_FilledPolysList.DeleteCorners( indexstart, indexend );
indexend = indexstart; /* indexstart points the first point of the next polygon
* because the current poly is removed */
}
} }
} }
} }
EDA_RECT ZONE_CONTAINER::CalculateSubAreaBoundaryBox( int aIndexStart, int aIndexEnd )
{
CPolyPt start_point, end_point;
EDA_RECT bbox;
start_point = m_FilledPolysList[aIndexStart];
end_point = start_point;
for( int ii = aIndexStart; ii <= aIndexEnd; ii++ )
{
CPolyPt ptst = m_FilledPolysList[ii];
if( start_point.x > ptst.x )
start_point.x = ptst.x;
if( start_point.y > ptst.y )
start_point.y = ptst.y;
if( end_point.x < ptst.x )
end_point.x = ptst.x;
if( end_point.y < ptst.y )
end_point.y = ptst.y;
}
bbox.SetOrigin( start_point.x, start_point.y );
bbox.SetEnd( wxPoint( end_point.x, end_point.y ) );
return bbox;
}

37
pcbnew/zones_polygons_test_connections.cpp
View File

@ -51,8 +51,8 @@ void Merge_SubNets_Connected_By_CopperAreas( BOARD* aPcb, int aNetcode );
bool sort_areas( const ZONE_CONTAINER* ref, const ZONE_CONTAINER* tst ) bool sort_areas( const ZONE_CONTAINER* ref, const ZONE_CONTAINER* tst )
{ {
if( ref->GetNetCode() == tst->GetNetCode() ) if( ref->GetNetCode() == tst->GetNetCode() )
return ref->GetFilledPolysList().GetCornersCount() < return ref->GetFilledPolysList().TotalVertices() <
tst->GetFilledPolysList().GetCornersCount(); tst->GetFilledPolysList().TotalVertices();
else else
return ref->GetNetCode() < tst->GetNetCode(); return ref->GetNetCode() < tst->GetNetCode();
} }
@ -101,7 +101,7 @@ void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
if( aNetcode >= 0 && aNetcode != zone->GetNetCode() ) if( aNetcode >= 0 && aNetcode != zone->GetNetCode() )
continue; continue;
if( zone->GetFilledPolysList().GetCornersCount() == 0 ) if( zone->GetFilledPolysList().IsEmpty() )
continue; continue;
zones_candidates.push_back( zone ); zones_candidates.push_back( zone );
@ -156,16 +156,11 @@ void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
} }
// test if a candidate is inside a filled area of this zone // test if a candidate is inside a filled area of this zone
unsigned indexstart = 0, indexend; const SHAPE_POLY_SET& polysList = zone->GetFilledPolysList();
const CPOLYGONS_LIST& polysList = zone->GetFilledPolysList();
for( indexend = 0; indexend < polysList.GetCornersCount(); indexend++ ) for( int outline = 0; outline < polysList.OutlineCount(); outline++ )
{
// end of a filled sub-area found
if( polysList.IsEndContour( indexend ) )
{ {
subnet++; subnet++;
EDA_RECT bbox = zone->CalculateSubAreaBoundaryBox( indexstart, indexend );
for( unsigned ic = 0; ic < candidates.size(); ic++ ) for( unsigned ic = 0; ic < candidates.size(); ic++ )
{ {
@ -207,22 +202,14 @@ void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
bool connected = false; bool connected = false;
if( bbox.Contains( pos1 ) ) if( polysList.Contains( VECTOR2I( pos1.x, pos1.y ), outline ) )
{
if( TestPointInsidePolygon( polysList, indexstart,
indexend, pos1.x, pos1.y ) )
connected = true; connected = true;
}
if( !connected && (pos1 != pos2 ) ) if( !connected && ( pos1 != pos2 ) )
{ {
if( bbox.Contains( pos2 ) ) if( polysList.Contains( VECTOR2I( pos2.x, pos2.y ), outline ) )
{
if( TestPointInsidePolygon( polysList,
indexstart, indexend,
pos2.x, pos2.y ) )
connected = true; connected = true;
} }
}
if( connected ) if( connected )
{ {
@ -247,13 +234,7 @@ void BOARD::Test_Connections_To_Copper_Areas( int aNetcode )
} // End if ( old_subnet > 0 ) } // End if ( old_subnet > 0 )
} // End if( connected ) } // End if( connected )
} }
// End test candidates for the current filled area
indexstart = indexend + 1; // prepare test next area, starting at indexend+1
// (if exists). End read one area in
// zone->m_FilledPolysList
} }
} // End read all segments in zone
} // End read all zones candidates } // End read all zones candidates
} }

50
pcbnew/zones_test_and_combine_areas.cpp
View File

@ -290,62 +290,26 @@ bool BOARD::CombineAreas( PICKED_ITEMS_LIST* aDeletedList, ZONE_CONTAINER* area_
return false; return false;
} }
// polygons intersect, combine them SHAPE_POLY_SET mergedOutlines = ConvertPolyListToPolySet( area_ref->Outline()->m_CornersList );
KI_POLYGON_WITH_HOLES areaRefPoly; SHAPE_POLY_SET areaToMergePoly = ConvertPolyListToPolySet( area_to_combine->Outline()->m_CornersList );
KI_POLYGON_WITH_HOLES areaToMergePoly;
area_ref->Outline()->m_CornersList.ExportTo( areaRefPoly );
area_to_combine->Outline()->m_CornersList.ExportTo( areaToMergePoly );
KI_POLYGON_WITH_HOLES_SET mergedOutlines; mergedOutlines.BooleanAdd( areaToMergePoly );
mergedOutlines.push_back( areaRefPoly ); mergedOutlines.Simplify();
mergedOutlines |= areaToMergePoly;
// We should have one polygon with hole // We should have one polygon with hole
// We can have 2 polygons with hole, if the 2 initial polygons have only one common corner // We can have 2 polygons with hole, if the 2 initial polygons have only one common corner
// and therefore cannot be merged (they are dectected as intersecting) // and therefore cannot be merged (they are dectected as intersecting)
// but we should never have more than 2 polys // but we should never have more than 2 polys
if( mergedOutlines.size() > 2 ) if( mergedOutlines.OutlineCount() > 2 )
{ {
wxLogMessage(wxT("BOARD::CombineAreas error: more than 2 polys after merging") ); wxLogMessage(wxT("BOARD::CombineAreas error: more than 2 polys after merging") );
return false; return false;
} }
if( mergedOutlines.size() > 1 ) if( mergedOutlines.OutlineCount() > 1 )
return false; return false;
areaRefPoly = mergedOutlines[0]; area_ref->Outline()->m_CornersList = ConvertPolySetToPolyList( mergedOutlines );
area_ref->Outline()->RemoveAllContours();
KI_POLYGON_WITH_HOLES::iterator_type corner = areaRefPoly.begin();
// create area with external contour: Recreate only area edges, NOT holes
area_ref->Outline()->Start( area_ref->GetLayer(), corner->x(), corner->y(),
area_ref->Outline()->GetHatchStyle() );
while( ++corner != areaRefPoly.end() )
{
area_ref->Outline()->AppendCorner( corner->x(), corner->y() );
}
area_ref->Outline()->CloseLastContour();
// add holes (set of polygons)
KI_POLYGON_WITH_HOLES::iterator_holes_type hole = areaRefPoly.begin_holes();
while( hole != areaRefPoly.end_holes() )
{
KI_POLYGON::iterator_type hole_corner = hole->begin();
// create area with external contour: Recreate only area edges, NOT holes
while( hole_corner != hole->end() )
{
area_ref->Outline()->AppendCorner( hole_corner->x(), hole_corner->y() );
hole_corner++;
}
area_ref->Outline()->CloseLastContour();
hole++;
}
RemoveArea( aDeletedList, area_to_combine ); RemoveArea( aDeletedList, area_to_combine );

6
polygon/CMakeLists.txt
View File

@ -9,12 +9,6 @@ set(POLYGON_SRCS
PolyLine.cpp PolyLine.cpp
polygon_test_point_inside.cpp polygon_test_point_inside.cpp
clipper.cpp clipper.cpp
poly2tri/common/shapes.cc
poly2tri/sweep/sweep.cc
poly2tri/sweep/cdt.cc
poly2tri/sweep/advancing_front.cc
poly2tri/sweep/sweep_context.cc
) )
add_library(polygon STATIC ${POLYGON_SRCS}) add_library(polygon STATIC ${POLYGON_SRCS})

563
polygon/PolyLine.cpp
View File

@ -115,85 +115,19 @@ CPolyLine::~CPolyLine()
* @return the polygon count (always >= 1, because there is at least one polygon) * @return the polygon count (always >= 1, because there is at least one polygon)
* There are new polygons only if the polygon count is > 1 * There are new polygons only if the polygon count is > 1
*/ */
#include "clipper.hpp"
int CPolyLine::NormalizeAreaOutlines( std::vector<CPolyLine*>* aNewPolygonList ) int CPolyLine::NormalizeAreaOutlines( std::vector<CPolyLine*>* aNewPolygonList )
{ {
ClipperLib::Path raw_polygon;
ClipperLib::Paths normalized_polygons;
unsigned corners_count = m_CornersList.GetCornersCount(); SHAPE_POLY_SET polySet = ConvertPolyListToPolySet( m_CornersList );
KI_POLYGON_SET polysholes; polySet.Simplify();
KI_POLYGON_WITH_HOLES mainpoly;
std::vector<KI_POLY_POINT> cornerslist;
KI_POLYGON_WITH_HOLES_SET all_contours;
KI_POLYGON poly_tmp;
// Normalize first contour
unsigned ic = 0;
while( ic < corners_count )
{
const CPolyPt& corner = m_CornersList[ic++];
raw_polygon.push_back( ClipperLib::IntPoint( corner.x, corner.y ) );
if( corner.end_contour )
break;
}
ClipperLib::SimplifyPolygon( raw_polygon, normalized_polygons );
// enter main outline
for( unsigned ii = 0; ii < normalized_polygons.size(); ii++ )
{
ClipperLib::Path& polygon = normalized_polygons[ii];
cornerslist.clear();
for( unsigned jj = 0; jj < polygon.size(); jj++ )
cornerslist.push_back( KI_POLY_POINT( KiROUND( polygon[jj].X ),
KiROUND( polygon[jj].Y ) ) );
mainpoly.set( cornerslist.begin(), cornerslist.end() );
all_contours.push_back( mainpoly );
}
// Enter holes
while( ic < corners_count )
{
cornerslist.clear();
raw_polygon.clear();
normalized_polygons.clear();
// Normalize current hole and add it to hole list
while( ic < corners_count )
{
const CPolyPt& corner = m_CornersList[ic++];
raw_polygon.push_back( ClipperLib::IntPoint( corner.x, corner.y ) );
if( corner.end_contour )
{
ClipperLib::SimplifyPolygon( raw_polygon, normalized_polygons );
for( unsigned ii = 0; ii < normalized_polygons.size(); ii++ )
{
ClipperLib::Path& polygon = normalized_polygons[ii];
cornerslist.clear();
for( unsigned jj = 0; jj < polygon.size(); jj++ )
cornerslist.push_back( KI_POLY_POINT( KiROUND( polygon[jj].X ),
KiROUND( polygon[jj].Y ) ) );
bpl::set_points( poly_tmp, cornerslist.begin(), cornerslist.end() );
polysholes.push_back( poly_tmp );
}
break;
}
}
}
all_contours -= polysholes;
// copy polygon with holes to destination
RemoveAllContours(); RemoveAllContours();
#define outlines all_contours for( int ii = 0; ii < polySet.OutlineCount(); ii++ )
for( unsigned ii = 0; ii < outlines.size(); ii++ )
{ {
CPolyLine* polyline = this; CPolyLine* polyline = this;
if( ii > 0 ) if( ii > 0 )
{ {
polyline = new CPolyLine; polyline = new CPolyLine;
@ -201,35 +135,14 @@ int CPolyLine::NormalizeAreaOutlines( std::vector<CPolyLine*>* aNewPolygonList )
aNewPolygonList->push_back( polyline ); aNewPolygonList->push_back( polyline );
} }
KI_POLYGON_WITH_HOLES& curr_poly = outlines[ii]; SHAPE_POLY_SET pnew;
KI_POLYGON_WITH_HOLES::iterator_type corner = curr_poly.begin(); pnew.NewOutline();
// enter main contour pnew.Polygon( 0 ) = polySet.CPolygon( ii );
while( corner != curr_poly.end() )
{
polyline->AppendCorner( corner->x(), corner->y() );
corner++;
}
polyline->CloseLastContour();
// add holes (set of polygons) polyline->m_CornersList = ConvertPolySetToPolyList( pnew );
KI_POLYGON_WITH_HOLES::iterator_holes_type hole = curr_poly.begin_holes();
while( hole != curr_poly.end_holes() )
{
KI_POLYGON::iterator_type hole_corner = hole->begin();
// create area with external contour: Recreate only area edges, NOT holes
while( hole_corner != hole->end() )
{
polyline->AppendCorner( hole_corner->x(), hole_corner->y() );
hole_corner++;
}
polyline->CloseLastContour();
hole++;
} }
polyline->RemoveNullSegments(); return polySet.OutlineCount();
}
return outlines.size();
} }
/** /**
@ -1260,375 +1173,6 @@ int CPolyLine::HitTestForCorner( const wxPoint& aPos, int aDistMax ) const
return corner; return corner;
} }
/*
* Copy the contours to a KI_POLYGON_WITH_HOLES
* The first contour is the main outline, others are holes
*/
void CPOLYGONS_LIST::ExportTo( KI_POLYGON_WITH_HOLES& aPolygoneWithHole ) const
{
unsigned corners_count = m_cornersList.size();
std::vector<KI_POLY_POINT> cornerslist;
KI_POLYGON poly;
// Enter main outline: this is the first contour
unsigned ic = 0;
while( ic < corners_count )
{
const CPolyPt& corner = GetCorner( ic++ );
cornerslist.push_back( KI_POLY_POINT( corner.x, corner.y ) );
if( corner.end_contour )
break;
}
aPolygoneWithHole.set( cornerslist.begin(), cornerslist.end() );
// Enter holes: they are next contours (when exist)
if( ic < corners_count )
{
KI_POLYGON_SET holePolyList;
while( ic < corners_count )
{
cornerslist.clear();
while( ic < corners_count )
{
cornerslist.push_back( KI_POLY_POINT( GetX( ic ), GetY( ic ) ) );
if( IsEndContour( ic++ ) )
break;
}
bpl::set_points( poly, cornerslist.begin(), cornerslist.end() );
holePolyList.push_back( poly );
}
aPolygoneWithHole.set_holes( holePolyList.begin(), holePolyList.end() );
}
}
/**
* Copy all contours to a KI_POLYGON_SET aPolygons
* Each contour is copied into a KI_POLYGON, and each KI_POLYGON
* is append to aPolygons
*/
void CPOLYGONS_LIST::ExportTo( KI_POLYGON_SET& aPolygons ) const
{
std::vector<KI_POLY_POINT> cornerslist;
unsigned corners_count = GetCornersCount();
// Count the number of polygons in aCornersBuffer
int polycount = 0;
for( unsigned ii = 0; ii < corners_count; ii++ )
{
if( IsEndContour( ii ) )
polycount++;
}
aPolygons.reserve( polycount );
for( unsigned icnt = 0; icnt < corners_count; )
{
KI_POLYGON poly;
cornerslist.clear();
unsigned ii;
for( ii = icnt; ii < corners_count; ii++ )
{
cornerslist.push_back( KI_POLY_POINT( GetX( ii ), GetY( ii ) ) );
if( IsEndContour( ii ) )
break;
}
bpl::set_points( poly, cornerslist.begin(), cornerslist.end() );
aPolygons.push_back( poly );
icnt = ii + 1;
}
}
/*
* Copy all contours to a ClipperLib::Paths& aPolygons
* Each contour is copied into a ClipperLib::Path, and each ClipperLib::Path
* is append to aPolygons
*/
void CPOLYGONS_LIST::ExportTo( ClipperLib::Paths& aPolygons ) const
{
unsigned corners_count = GetCornersCount();
// Count the number of polygons in aCornersBuffer
int polycount = 0;
for( unsigned ii = 0; ii < corners_count; ii++ )
{
if( IsEndContour( ii ) )
polycount++;
}
aPolygons.reserve( polycount );
for( unsigned icnt = 0; icnt < corners_count; )
{
ClipperLib::Path poly;
unsigned ii;
for( ii = icnt; ii < corners_count; ii++ )
{
poly << ClipperLib::IntPoint( GetX( ii ), GetY( ii ) );
if( IsEndContour( ii ) )
break;
}
aPolygons.push_back( poly );
icnt = ii + 1;
}
}
/* Imports all polygons found in a KI_POLYGON_SET in list
*/
void CPOLYGONS_LIST::ImportFrom( KI_POLYGON_SET& aPolygons )
{
CPolyPt corner;
for( unsigned ii = 0; ii < aPolygons.size(); ii++ )
{
KI_POLYGON& poly = aPolygons[ii];
for( unsigned jj = 0; jj < poly.size(); jj++ )
{
KI_POLY_POINT point = *(poly.begin() + jj);
corner.x = point.x();
corner.y = point.y();
corner.end_contour = false;
AddCorner( corner );
}
CloseLastContour();
}
}
/* Imports all polygons found in a ClipperLib::Paths in list
*/
void CPOLYGONS_LIST::ImportFrom( ClipperLib::Paths& aPolygons )
{
CPolyPt corner;
for( unsigned ii = 0; ii < aPolygons.size(); ii++ )
{
ClipperLib::Path& polygon = aPolygons[ii];
for( unsigned jj = 0; jj < polygon.size(); jj++ )
{
corner.x = int( polygon[jj].X );
corner.y = int( polygon[jj].Y );
corner.end_contour = false;
AddCorner( corner );
}
CloseLastContour();
}
}
/* Inflate the outline stored in m_cornersList.
* The first polygon is the external outline. It is inflated
* The other polygons are holes. they are deflated
* aResult = the Inflated outline
* aInflateValue = the Inflate value. when < 0, this is a deflate transform
* aLinkHoles = if true, aResult contains only one polygon,
* with holes linked by overlapping segments
*
* Important Note:
* Inflating a polygon with acute angles or a non convex polygon gives non optimal shapes
* for your purposes (creating a clearance area from zones).
* So when inflating a polygon, we combine it with a "thick outline"
* with a thickness = aInflateValue*2.
* the inflated polygon shape is much better to build a polygon
* from a polygon + clearance area
*
* Generic algos (Clipper, Boost Polygon) can inflate polygons, but the result is
* not always suitable (they work fine only for polygons with non acute angle)
*
* To deflate polygons, the same calculation is made, but instead of adding the "thick outline"
* we substract it.
*/
#include <convert_basic_shapes_to_polygon.h>
void CPOLYGONS_LIST::InflateOutline( CPOLYGONS_LIST& aResult, int aInflateValue, bool aLinkHoles )
{
KI_POLYGON_SET polyset_outline;
ExportTo( polyset_outline );
// Extract holes (cutout areas) and add them to the hole buffer
KI_POLYGON_SET outlineHoles;
while( polyset_outline.size() > 1 )
{
outlineHoles.push_back( polyset_outline.back() );
polyset_outline.pop_back();
}
// inflate main outline
unsigned icnt = 0;
int width = std::abs( aInflateValue * 2 );
if( polyset_outline.size() )
{
CPOLYGONS_LIST outlines;
for( ; icnt < GetCornersCount(); icnt++ )
{
unsigned ii = icnt+1;
if( IsEndContour( icnt ) )
ii = 0;
TransformRoundedEndsSegmentToPolygon( outlines,
GetPos( icnt ), GetPos( ii ), 16, width );
if( IsEndContour( icnt ) )
break;
}
KI_POLYGON_SET thicklines;
outlines.ExportTo( thicklines );
if( aInflateValue > 0 ) // Inflate main outline
polyset_outline += thicklines;
else if( aInflateValue < 0 ) // Actually a deflate transform
polyset_outline -= thicklines; // deflate main outline
}
// deflate outline holes
if( outlineHoles.size() )
{
int deflateValue = -aInflateValue;
CPOLYGONS_LIST outlines;
icnt += 1; // points the first point of the first hole
unsigned firstpoint = icnt;
for( ; icnt < GetCornersCount(); icnt++ )
{
unsigned ii = icnt+1;
if( IsEndContour( icnt ) || ii >= GetCornersCount() )
{
ii = firstpoint;
firstpoint = icnt+1;
}
TransformRoundedEndsSegmentToPolygon( outlines,
GetPos( icnt ), GetPos( ii ), 16, width );
}
KI_POLYGON_SET thicklines;
outlines.ExportTo( thicklines );
if( deflateValue > 0 ) // Inflate holes
outlineHoles += thicklines;
else if( deflateValue < 0 ) // deflate holes
outlineHoles -= thicklines;
}
// Copy modified polygons
if( !aLinkHoles )
{
aResult.ImportFrom( polyset_outline );
if( outlineHoles.size() )
aResult.ImportFrom( outlineHoles );
}
else
{
polyset_outline -= outlineHoles;
aResult.ImportFrom( polyset_outline );
}
}
/**
* Function ConvertPolysListWithHolesToOnePolygon
* converts the outline contours aPolysListWithHoles with holes to one polygon
* with no holes (only one contour)
* holes are linked to main outlines by overlap segments, to give only one polygon
*
* @param aPolysListWithHoles = the list of corners of contours (haing holes
* @param aOnePolyList = a polygon with no holes
*/
void ConvertPolysListWithHolesToOnePolygon( const CPOLYGONS_LIST& aPolysListWithHoles,
CPOLYGONS_LIST& aOnePolyList )
{
unsigned corners_count = aPolysListWithHoles.GetCornersCount();
int polycount = 0;
for( unsigned ii = 0; ii < corners_count; ii++ )
{
if( aPolysListWithHoles.IsEndContour( ii ) )
polycount++;
}
// If polycount<= 1, there is no holes found, and therefore just copy the polygon.
if( polycount <= 1 )
{
aOnePolyList.Append( aPolysListWithHoles );
return;
}
// Holes are found: convert them to only one polygon with overlap segments
KI_POLYGON_SET polysholes;
KI_POLYGON_SET mainpoly;
KI_POLYGON poly_tmp;
std::vector<KI_POLY_POINT> cornerslist;
corners_count = aPolysListWithHoles.GetCornersCount();
unsigned ic = 0;
// enter main outline
while( ic < corners_count )
{
const CPolyPt& corner = aPolysListWithHoles.GetCorner( ic++ );
cornerslist.push_back( KI_POLY_POINT( corner.x, corner.y ) );
if( corner.end_contour )
break;
}
bpl::set_points( poly_tmp, cornerslist.begin(), cornerslist.end() );
mainpoly.push_back( poly_tmp );
while( ic < corners_count )
{
cornerslist.clear();
{
while( ic < corners_count )
{
const CPolyPt& corner = aPolysListWithHoles.GetCorner( ic++ );
cornerslist.push_back( KI_POLY_POINT( corner.x, corner.y ) );
if( corner.end_contour )
break;
}
bpl::set_points( poly_tmp, cornerslist.begin(), cornerslist.end() );
polysholes.push_back( poly_tmp );
}
}
mainpoly -= polysholes;
// copy polygon with no holes to destination
// Because all holes are now linked to the main outline
// by overlapping segments, we should have only one polygon in list
wxASSERT( mainpoly.size() == 1 );
aOnePolyList.ImportFrom( mainpoly );
}
/** /**
* Function IsPolygonSelfIntersecting * Function IsPolygonSelfIntersecting
@ -1724,21 +1268,80 @@ bool CPolyLine::IsPolygonSelfIntersecting()
return false; return false;
} }
const SHAPE_POLY_SET ConvertPolyListToPolySet( const CPOLYGONS_LIST& aList )
/* converts the outline aOnePolyList (only one contour,
* holes are linked by overlapping segments) to
* to one main polygon and holes (polygons inside main polygon)
* aOnePolyList = a only one polygon ( holes are linked )
* aPolysListWithHoles = the list of corners of contours
* (main outline and holes)
*/
void ConvertOnePolygonToPolysListWithHoles( const CPOLYGONS_LIST& aOnePolyList,
CPOLYGONS_LIST& aPolysListWithHoles )
{ {
ClipperLib::Paths initialPoly; SHAPE_POLY_SET rv;
ClipperLib::Paths modifiedPoly;
aOnePolyList.ExportTo( initialPoly ); unsigned corners_count = aList.GetCornersCount();
SimplifyPolygon(initialPoly[0], modifiedPoly );
aPolysListWithHoles.ImportFrom( modifiedPoly ); // Enter main outline: this is the first contour
unsigned ic = 0;
if( !corners_count )
return rv;
int index = 0;
while( ic < corners_count )
{
int hole = -1;
if( index == 0 )
{
rv.NewOutline();
hole = -1;
}
else
{
hole = rv.NewHole();
}
while( ic < corners_count )
{
rv.Append( aList.GetX( ic ), aList.GetY( ic ), 0, hole );
if( aList.IsEndContour( ic ) )
break;
ic++;
}
ic++;
index++;
}
return rv;
}
const CPOLYGONS_LIST ConvertPolySetToPolyList(const SHAPE_POLY_SET& aPolyset)
{
CPOLYGONS_LIST list;
CPolyPt corner, firstCorner;
const SHAPE_POLY_SET::POLYGON& poly = aPolyset.CPolygon( 0 );
for( unsigned int jj = 0; jj < poly.size() ; jj++ )
{
const SHAPE_LINE_CHAIN& path = poly[jj];
for( int i = 0; i < path.PointCount(); i++ )
{
const VECTOR2I &v = path.CPoint( i );
corner.x = v.x;
corner.y = v.y;
corner.end_contour = false;
if( i == 0 )
firstCorner = corner;
list.AddCorner( corner );
}
firstCorner.end_contour = true;
list.AddCorner( firstCorner );
}
return list;
} }

103
polygon/PolyLine.h
View File

@ -53,8 +53,8 @@
#include <wx/gdicmn.h> // for wxPoint definition #include <wx/gdicmn.h> // for wxPoint definition
#include <layers_id_colors_and_visibility.h> // for LAYER_NUM definition #include <layers_id_colors_and_visibility.h> // for LAYER_NUM definition
#include <class_eda_rect.h> // for EDA_RECT definition #include <class_eda_rect.h> // for EDA_RECT definition
#include <polygons_defs.h>
#include <clipper.hpp> #include <geometry/shape_poly_set.h> // fixme
class CSegment class CSegment
{ {
@ -116,30 +116,21 @@ private:
public: public:
CPOLYGONS_LIST() {}; CPOLYGONS_LIST() {};
CPolyPt& operator [](int aIdx) {return m_cornersList[aIdx]; } CPolyPt& operator [](int aIdx) { return m_cornersList[aIdx]; }
// Accessor: // Accessor:
const std::vector <CPolyPt>& GetList() const {return m_cornersList;} const std::vector <CPolyPt>& GetList() const {return m_cornersList;}
int GetX( int ic ) const { return m_cornersList[ic].x; } int GetX( int ic ) const { return m_cornersList[ic].x; }
void SetX( int ic, int aValue ) { m_cornersList[ic].x = aValue; } void SetX( int ic, int aValue ) { m_cornersList[ic].x = aValue; }
int GetY( int ic ) const { return m_cornersList[ic].y; } int GetY( int ic ) const { return m_cornersList[ic].y; }
void SetY( int ic, int aValue ) { m_cornersList[ic].y = aValue; } void SetY( int ic, int aValue ) { m_cornersList[ic].y = aValue; }
int GetUtility( int ic ) const { return m_cornersList[ic].m_flags; }
void SetFlag( int ic, int aFlag )
{
m_cornersList[ic].m_flags = aFlag;
}
bool IsEndContour( int ic ) const bool IsEndContour( int ic ) const
{ {
return m_cornersList[ic].end_contour; return m_cornersList[ic].end_contour;
} }
void SetEndContour( int ic, bool end_contour )
{
m_cornersList[ic].end_contour = end_contour;
}
const wxPoint& GetPos( int ic ) const { return m_cornersList[ic]; } const wxPoint& GetPos( int ic ) const { return m_cornersList[ic]; }
const CPolyPt& GetCorner( int ic ) const { return m_cornersList[ic]; } const CPolyPt& GetCorner( int ic ) const { return m_cornersList[ic]; }
@ -157,6 +148,7 @@ public:
m_cornersList.erase( m_cornersList.begin() + aIdx ); m_cornersList.erase( m_cornersList.begin() + aIdx );
} }
// used only to erase an entire polygon
void DeleteCorners( int aIdFirstCorner, int aIdLastCorner ) void DeleteCorners( int aIdFirstCorner, int aIdLastCorner )
{ {
m_cornersList.erase( m_cornersList.begin() + aIdFirstCorner, m_cornersList.erase( m_cornersList.begin() + aIdFirstCorner,
@ -212,56 +204,6 @@ public:
* (number of corners flagged "end_contour" * (number of corners flagged "end_contour"
*/ */
int GetContoursCount() const; int GetContoursCount() const;
/**
* Function ExportTo
* Copy all contours to a KI_POLYGON_SET, each contour is exported
* to a KI_POLYGON
* @param aPolygons = the KI_POLYGON_SET to populate
*/
void ExportTo( KI_POLYGON_SET& aPolygons ) const;
/**
* Function ExportTo
* Copy the contours to a KI_POLYGON_WITH_HOLES
* The first contour is the main outline, others are holes
* @param aPolygoneWithHole = the KI_POLYGON_WITH_HOLES to populate
*/
void ExportTo( KI_POLYGON_WITH_HOLES& aPolygoneWithHole ) const;
/**
* Function ExportTo
* Copy all contours to a ClipperLib::Paths, each contour is exported
* to a ClipperLib::Path
* @param aPolygons = the ClipperLib::Paths to populate
*/
void ExportTo( ClipperLib::Paths& aPolygons ) const;
/**
* Function ImportFrom
* Copy all polygons from a KI_POLYGON_SET in list
* @param aPolygons = the KI_POLYGON_SET to import
*/
void ImportFrom( KI_POLYGON_SET& aPolygons );
/**
* Function ImportFrom
* Copy all polygons from a ClipperLib::Paths in list
* @param aPolygons = the ClipperLib::Paths to import
*/
void ImportFrom( ClipperLib::Paths& aPolygons );
/**
* Function InflateOutline
* Inflate the outline stored in m_cornersList.
* The first polygon is the external outline. It is inflated
* The other polygons are holes. they are deflated
* @param aResult = the Inflated outline
* @param aInflateValue = the Inflate value. when < 0, this is a deflate transform
* @param aLinkHoles = if true, aResult contains only one polygon,
* with holes linked by overlapping segments
*/
void InflateOutline( CPOLYGONS_LIST& aResult, int aInflateValue, bool aLinkHoles );
}; };
class CPolyLine class CPolyLine
@ -447,9 +389,6 @@ public:
const wxPoint& GetPos( int ic ) const { return m_CornersList.GetPos( ic ); } const wxPoint& GetPos( int ic ) const { return m_CornersList.GetPos( ic ); }
int GetUtility( int ic ) const { return m_CornersList.GetUtility( ic ); };
void SetUtility( int ic, int aFlag ) { m_CornersList.SetFlag( ic, aFlag ); };
int GetHatchPitch() const { return m_hatchPitch; } int GetHatchPitch() const { return m_hatchPitch; }
static int GetDefaultHatchPitchMils() { return 20; } // default hatch pitch value in mils static int GetDefaultHatchPitchMils() { return 20; } // default hatch pitch value in mils
@ -473,11 +412,6 @@ public:
m_CornersList.SetY( ic, y ); m_CornersList.SetY( ic, y );
} }
void SetEndContour( int ic, bool end_contour )
{
m_CornersList.SetEndContour( ic, end_contour );
}
void SetHatchStyle( enum HATCH_STYLE style ) void SetHatchStyle( enum HATCH_STYLE style )
{ {
m_hatchStyle = style; m_hatchStyle = style;
@ -549,30 +483,7 @@ public:
std::vector <CSegment> m_HatchLines; // hatch lines showing the polygon area std::vector <CSegment> m_HatchLines; // hatch lines showing the polygon area
}; };
/** const SHAPE_POLY_SET ConvertPolyListToPolySet( const CPOLYGONS_LIST& aList );
* Function ConvertPolysListWithHolesToOnePolygon const CPOLYGONS_LIST ConvertPolySetToPolyList( const SHAPE_POLY_SET& aPolyset );
* converts the outline contours aPolysListWithHoles with holes to one polygon
* with no holes (only one contour)
* holes are linked to main outlines by overlap segments, to give only one polygon
*
* @param aPolysListWithHoles = the list of corners of contours
* (main outline and holes)
* @param aOnePolyList = a polygon with no holes
*/
void ConvertPolysListWithHolesToOnePolygon( const CPOLYGONS_LIST& aPolysListWithHoles,
CPOLYGONS_LIST& aOnePolyList );
/**
* Function ConvertOnePolygonToPolysListWithHoles
* converts the outline aOnePolyList (only one contour,
* holes are linked by overlapping segments) to
* to one main polygon and holes (polygons inside main polygon)
* @param aOnePolyList = a polygon with no holes
* @param aPolysListWithHoles = the list of corners of contours
* (main outline and holes)
*/
void ConvertOnePolygonToPolysListWithHoles( const CPOLYGONS_LIST& aOnePolyList,
CPOLYGONS_LIST& aPolysListWithHoles );
#endif // #ifndef POLYLINE_H #endif // #ifndef POLYLINE_H

500
polygon/poly2tri/common/shapes.cc
View File

@ -1,500 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "shapes.h"
#include <iostream>
namespace p2t {
Triangle::Triangle( Point& a, Point& b, Point& c )
{
points_[0] = &a; points_[1] = &b; points_[2] = &c;
neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false;
delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
interior_ = false;
}
// Update neighbor pointers
void Triangle::MarkNeighbor( Point* p1, Point* p2, Triangle* t )
{
if( (p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2]) )
neighbors_[0] = t;
else if( (p1 == points_[0] && p2 == points_[2]) || (p1 == points_[2] && p2 == points_[0]) )
neighbors_[1] = t;
else if( (p1 == points_[0] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[0]) )
neighbors_[2] = t;
else
assert( 0 );
}
// Exhaustive search to update neighbor pointers
void Triangle::MarkNeighbor( Triangle& t )
{
if( t.Contains( points_[1], points_[2] ) )
{
neighbors_[0] = &t;
t.MarkNeighbor( points_[1], points_[2], this );
}
else if( t.Contains( points_[0], points_[2] ) )
{
neighbors_[1] = &t;
t.MarkNeighbor( points_[0], points_[2], this );
}
else if( t.Contains( points_[0], points_[1] ) )
{
neighbors_[2] = &t;
t.MarkNeighbor( points_[0], points_[1], this );
}
}
/**
* Clears all references to all other triangles and points
*/
void Triangle::Clear()
{
Triangle* t;
for( int i = 0; i<3; i++ )
{
t = neighbors_[i];
if( t != NULL )
{
t->ClearNeighbor( this );
}
}
ClearNeighbors();
points_[0] = points_[1] = points_[2] = NULL;
}
void Triangle::ClearNeighbor( Triangle* triangle )
{
if( neighbors_[0] == triangle )
{
neighbors_[0] = NULL;
}
else if( neighbors_[1] == triangle )
{
neighbors_[1] = NULL;
}
else
{
neighbors_[2] = NULL;
}
}
void Triangle::ClearNeighbors()
{
neighbors_[0] = NULL;
neighbors_[1] = NULL;
neighbors_[2] = NULL;
}
void Triangle::ClearDelunayEdges()
{
delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
}
Point* Triangle::OppositePoint( Triangle& t, Point& p )
{
Point* cw = t.PointCW( p );
/*
double x = cw->x;
double y = cw->y;
x = p.x;
y = p.y;
*/
return PointCW( *cw );
}
// Legalized triangle by rotating clockwise around point(0)
void Triangle::Legalize( Point& point )
{
points_[1] = points_[0];
points_[0] = points_[2];
points_[2] = &point;
}
// Legalize triagnle by rotating clockwise around oPoint
void Triangle::Legalize( Point& opoint, Point& npoint )
{
if( &opoint == points_[0] )
{
points_[1] = points_[0];
points_[0] = points_[2];
points_[2] = &npoint;
}
else if( &opoint == points_[1] )
{
points_[2] = points_[1];
points_[1] = points_[0];
points_[0] = &npoint;
}
else if( &opoint == points_[2] )
{
points_[0] = points_[2];
points_[2] = points_[1];
points_[1] = &npoint;
}
else
{
assert( 0 );
}
}
int Triangle::Index( const Point* p )
{
if( p == points_[0] )
{
return 0;
}
else if( p == points_[1] )
{
return 1;
}
else if( p == points_[2] )
{
return 2;
}
assert( 0 );
return 0; // you better hope its a Debug build.
}
int Triangle::EdgeIndex( const Point* p1, const Point* p2 )
{
if( points_[0] == p1 )
{
if( points_[1] == p2 )
{
return 2;
}
else if( points_[2] == p2 )
{
return 1;
}
}
else if( points_[1] == p1 )
{
if( points_[2] == p2 )
{
return 0;
}
else if( points_[0] == p2 )
{
return 2;
}
}
else if( points_[2] == p1 )
{
if( points_[0] == p2 )
{
return 1;
}
else if( points_[1] == p2 )
{
return 0;
}
}
return -1;
}
void Triangle::MarkConstrainedEdge( const int index )
{
constrained_edge[index] = true;
}
void Triangle::MarkConstrainedEdge( Edge& edge )
{
MarkConstrainedEdge( edge.p, edge.q );
}
// Mark edge as constrained
void Triangle::MarkConstrainedEdge( Point* p, Point* q )
{
if( (q == points_[0] && p == points_[1]) || (q == points_[1] && p == points_[0]) )
{
constrained_edge[2] = true;
}
else if( (q == points_[0] && p == points_[2]) || (q == points_[2] && p == points_[0]) )
{
constrained_edge[1] = true;
}
else if( (q == points_[1] && p == points_[2]) || (q == points_[2] && p == points_[1]) )
{
constrained_edge[0] = true;
}
}
// The point counter-clockwise to given point
Point* Triangle::PointCW( Point& point )
{
if( &point == points_[0] )
{
return points_[2];
}
else if( &point == points_[1] )
{
return points_[0];
}
else if( &point == points_[2] )
{
return points_[1];
}
assert( 0 );
return NULL; // you better hope its a Debug build.
}
// The point counter-clockwise to given point
Point* Triangle::PointCCW( Point& point )
{
if( &point == points_[0] )
{
return points_[1];
}
else if( &point == points_[1] )
{
return points_[2];
}
else if( &point == points_[2] )
{
return points_[0];
}
assert( 0 );
return NULL; // you better hope its a Debug build.
}
// The neighbor clockwise to given point
Triangle* Triangle::NeighborCW( Point& point )
{
if( &point == points_[0] )
{
return neighbors_[1];
}
else if( &point == points_[1] )
{
return neighbors_[2];
}
return neighbors_[0];
}
// The neighbor counter-clockwise to given point
Triangle* Triangle::NeighborCCW( Point& point )
{
if( &point == points_[0] )
{
return neighbors_[2];
}
else if( &point == points_[1] )
{
return neighbors_[0];
}
return neighbors_[1];
}
bool Triangle::GetConstrainedEdgeCCW( Point& p )
{
if( &p == points_[0] )
{
return constrained_edge[2];
}
else if( &p == points_[1] )
{
return constrained_edge[0];
}
return constrained_edge[1];
}
bool Triangle::GetConstrainedEdgeCW( Point& p )
{
if( &p == points_[0] )
{
return constrained_edge[1];
}
else if( &p == points_[1] )
{
return constrained_edge[2];
}
return constrained_edge[0];
}
void Triangle::SetConstrainedEdgeCCW( Point& p, bool ce )
{
if( &p == points_[0] )
{
constrained_edge[2] = ce;
}
else if( &p == points_[1] )
{
constrained_edge[0] = ce;
}
else
{
constrained_edge[1] = ce;
}
}
void Triangle::SetConstrainedEdgeCW( Point& p, bool ce )
{
if( &p == points_[0] )
{
constrained_edge[1] = ce;
}
else if( &p == points_[1] )
{
constrained_edge[2] = ce;
}
else
{
constrained_edge[0] = ce;
}
}
bool Triangle::GetDelunayEdgeCCW( Point& p )
{
if( &p == points_[0] )
{
return delaunay_edge[2];
}
else if( &p == points_[1] )
{
return delaunay_edge[0];
}
return delaunay_edge[1];
}
bool Triangle::GetDelunayEdgeCW( Point& p )
{
if( &p == points_[0] )
{
return delaunay_edge[1];
}
else if( &p == points_[1] )
{
return delaunay_edge[2];
}
return delaunay_edge[0];
}
void Triangle::SetDelunayEdgeCCW( Point& p, bool e )
{
if( &p == points_[0] )
{
delaunay_edge[2] = e;
}
else if( &p == points_[1] )
{
delaunay_edge[0] = e;
}
else
{
delaunay_edge[1] = e;
}
}
void Triangle::SetDelunayEdgeCW( Point& p, bool e )
{
if( &p == points_[0] )
{
delaunay_edge[1] = e;
}
else if( &p == points_[1] )
{
delaunay_edge[2] = e;
}
else
{
delaunay_edge[0] = e;
}
}
// The neighbor across to given point
Triangle& Triangle::NeighborAcross( Point& opoint )
{
if( &opoint == points_[0] )
{
return *neighbors_[0];
}
else if( &opoint == points_[1] )
{
return *neighbors_[1];
}
return *neighbors_[2];
}
void Triangle::DebugPrint()
{
std::cout << points_[0]->x << "," << points_[0]->y << " ";
std::cout << points_[1]->x << "," << points_[1]->y << " ";
std::cout << points_[2]->x << "," << points_[2]->y << "\n";
}
}

351
polygon/poly2tri/common/shapes.h
View File

@ -1,351 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Include guard
#ifndef SHAPES_H
#define SHAPES_H
#include <vector>
#include <cstddef>
#include <assert.h>
#include <cmath>
namespace p2t {
struct Edge;
struct Point
{
double x, y;
/// Default constructor does nothing (for performance).
Point()
{
x = 0.0;
y = 0.0;
}
/// The edges this point constitutes an upper ending point
std::vector<Edge*> edge_list;
/// Construct using coordinates.
Point( double x, double y ) : x( x ), y( y ) {}
/// Set this point to all zeros.
void set_zero()
{
x = 0.0;
y = 0.0;
}
/// Set this point to some specified coordinates.
void set( double x_, double y_ )
{
x = x_;
y = y_;
}
/// Negate this point.
Point operator -() const
{
Point v;
v.set( -x, -y );
return v;
}
/// Add a point to this point.
void operator +=( const Point& v )
{
x += v.x;
y += v.y;
}
/// Subtract a point from this point.
void operator -=( const Point& v )
{
x -= v.x;
y -= v.y;
}
/// Multiply this point by a scalar.
void operator *=( double a )
{
x *= a;
y *= a;
}
/// Get the length of this point (the norm).
double Length() const
{
return sqrt( x * x + y * y );
}
/// Convert this point into a unit point. Returns the Length.
double Normalize()
{
double len = Length();
x /= len;
y /= len;
return len;
}
};
// Represents a simple polygon's edge
struct Edge
{
Point* p, * q;
/// Constructor
Edge( Point& p1, Point& p2 ) : p( &p1 ), q( &p2 )
{
if( p1.y > p2.y )
{
q = &p1;
p = &p2;
}
else if( p1.y == p2.y )
{
if( p1.x > p2.x )
{
q = &p1;
p = &p2;
}
else if( p1.x == p2.x )
{
// Repeat points
assert( false );
}
}
q->edge_list.push_back( this );
}
};
// Triangle-based data structures are know to have better performance than quad-edge structures
// See: J. Shewchuk, "Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator"
// "Triangulations in CGAL"
class Triangle
{
public:
/// Constructor
Triangle( Point& a, Point& b, Point& c );
/// Flags to determine if an edge is a Constrained edge
bool constrained_edge[3];
/// Flags to determine if an edge is a Delauney edge
bool delaunay_edge[3];
Point* GetPoint( const int& index );
Point* PointCW( Point& point );
Point* PointCCW( Point& point );
Point* OppositePoint( Triangle& t, Point& p );
Triangle* GetNeighbor( const int& index );
void MarkNeighbor( Point* p1, Point* p2, Triangle* t );
void MarkNeighbor( Triangle& t );
void MarkConstrainedEdge( const int index );
void MarkConstrainedEdge( Edge& edge );
void MarkConstrainedEdge( Point* p, Point* q );
int Index( const Point* p );
int EdgeIndex( const Point* p1, const Point* p2 );
Triangle* NeighborCW( Point& point );
Triangle* NeighborCCW( Point& point );
bool GetConstrainedEdgeCCW( Point& p );
bool GetConstrainedEdgeCW( Point& p );
void SetConstrainedEdgeCCW( Point& p, bool ce );
void SetConstrainedEdgeCW( Point& p, bool ce );
bool GetDelunayEdgeCCW( Point& p );
bool GetDelunayEdgeCW( Point& p );
void SetDelunayEdgeCCW( Point& p, bool e );
void SetDelunayEdgeCW( Point& p, bool e );
bool Contains( Point* p );
bool Contains( const Edge& e );
bool Contains( Point* p, Point* q );
void Legalize( Point& point );
void Legalize( Point& opoint, Point& npoint );
/**
* Clears all references to all other triangles and points
*/
void Clear();
void ClearNeighbor( Triangle* triangle );
void ClearNeighbors();
void ClearDelunayEdges();
inline bool IsInterior();
inline void IsInterior( bool b );
Triangle& NeighborAcross( Point& opoint );
void DebugPrint();
private:
/// Triangle points
Point* points_[3];
/// Neighbor list
Triangle* neighbors_[3];
/// Has this triangle been marked as an interior triangle?
bool interior_;
};
inline bool cmp( const Point* a, const Point* b )
{
if( a->y < b->y )
{
return true;
}
else if( a->y == b->y )
{
// Make sure q is point with greater x value
if( a->x < b->x )
{
return true;
}
}
return false;
}
/// Add two points_ component-wise.
inline Point operator +( const Point& a, const Point& b )
{
return Point( a.x + b.x, a.y + b.y );
}
/// Subtract two points_ component-wise.
inline Point operator -( const Point& a, const Point& b )
{
return Point( a.x - b.x, a.y - b.y );
}
/// Multiply point by scalar
inline Point operator *( double s, const Point& a )
{
return Point( s * a.x, s * a.y );
}
inline bool operator ==( const Point& a, const Point& b )
{
return a.x == b.x && a.y == b.y;
}
inline bool operator !=( const Point& a, const Point& b )
{
return !(a.x == b.x) && !(a.y == b.y);
}
/// Peform the dot product on two vectors.
inline double Dot( const Point& a, const Point& b )
{
return a.x * b.x + a.y * b.y;
}
/// Perform the cross product on two vectors. In 2D this produces a scalar.
inline double Cross( const Point& a, const Point& b )
{
return a.x * b.y - a.y * b.x;
}
/// Perform the cross product on a point and a scalar. In 2D this produces
/// a point.
inline Point Cross( const Point& a, double s )
{
return Point( s * a.y, -s * a.x );
}
/// Perform the cross product on a scalar and a point. In 2D this produces
/// a point.
inline Point Cross( const double s, const Point& a )
{
return Point( -s * a.y, s * a.x );
}
inline Point* Triangle::GetPoint( const int& index )
{
return points_[index];
}
inline Triangle* Triangle::GetNeighbor( const int& index )
{
return neighbors_[index];
}
inline bool Triangle::Contains( Point* p )
{
return p == points_[0] || p == points_[1] || p == points_[2];
}
inline bool Triangle::Contains( const Edge& e )
{
return Contains( e.p ) && Contains( e.q );
}
inline bool Triangle::Contains( Point* p, Point* q )
{
return Contains( p ) && Contains( q );
}
inline bool Triangle::IsInterior()
{
return interior_;
}
inline void Triangle::IsInterior( bool b )
{
interior_ = b;
}
}
#endif

133
polygon/poly2tri/common/utils.h
View File

@ -1,133 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef UTILS_H
#define UTILS_H
// Otherwise #defines like M_PI are undeclared under Visual Studio
#define _USE_MATH_DEFINES
#include <exception>
#include <math.h>
namespace p2t {
const double PI_3div4 = 3 * M_PI / 4;
const double PI_div2 = 1.57079632679489661923;
const double EPSILON = 1e-12;
enum Orientation {
CW, CCW, COLLINEAR
};
/**
* Forumla to calculate signed area<br>
* Positive if CCW<br>
* Negative if CW<br>
* 0 if collinear<br>
* <pre>
* A[P1,P2,P3] = (x1*y2 - y1*x2) + (x2*y3 - y2*x3) + (x3*y1 - y3*x1)
* = (x1-x3)*(y2-y3) - (y1-y3)*(x2-x3)
* </pre>
*/
Orientation Orient2d( Point& pa, Point& pb, Point& pc )
{
double detleft = (pa.x - pc.x) * (pb.y - pc.y);
double detright = (pa.y - pc.y) * (pb.x - pc.x);
double val = detleft - detright;
if( val > -EPSILON && val < EPSILON )
{
return COLLINEAR;
}
else if( val > 0 )
{
return CCW;
}
return CW;
}
/*
* bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd)
* {
* double pdx = pd.x;
* double pdy = pd.y;
* double adx = pa.x - pdx;
* double ady = pa.y - pdy;
* double bdx = pb.x - pdx;
* double bdy = pb.y - pdy;
*
* double adxbdy = adx * bdy;
* double bdxady = bdx * ady;
* double oabd = adxbdy - bdxady;
*
* if (oabd <= EPSILON) {
* return false;
* }
*
* double cdx = pc.x - pdx;
* double cdy = pc.y - pdy;
*
* double cdxady = cdx * ady;
* double adxcdy = adx * cdy;
* double ocad = cdxady - adxcdy;
*
* if (ocad <= EPSILON) {
* return false;
* }
*
* return true;
* }
*
*/
bool InScanArea( Point& pa, Point& pb, Point& pc, Point& pd )
{
double oadb = (pa.x - pb.x) * (pd.y - pb.y) - (pd.x - pb.x) * (pa.y - pb.y);
if( oadb >= -EPSILON )
{
return false;
}
double oadc = (pa.x - pc.x) * (pd.y - pc.y) - (pd.x - pc.x) * (pa.y - pc.y);
if( oadc <= EPSILON )
{
return false;
}
return true;
}
}
#endif

39
polygon/poly2tri/poly2tri.h
View File

@ -1,39 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef POLY2TRI_H
#define POLY2TRI_H
#include "common/shapes.h"
#include "sweep/cdt.h"
#endif

109
polygon/poly2tri/sweep/advancing_front.cc
View File

@ -1,109 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "advancing_front.h"
namespace p2t {
AdvancingFront::AdvancingFront(Node& head, Node& tail)
{
head_ = &head;
tail_ = &tail;
search_node_ = &head;
}
Node* AdvancingFront::LocateNode(const double& x)
{
Node* node = search_node_;
if (x < node->value) {
while ((node = node->prev) != NULL) {
if (x >= node->value) {
search_node_ = node;
return node;
}
}
} else {
while ((node = node->next) != NULL) {
if (x < node->value) {
search_node_ = node->prev;
return node->prev;
}
}
}
return NULL;
}
Node* AdvancingFront::FindSearchNode(const double& x)
{
(void)x; // suppress compiler warnings "unused parameter 'x'"
// TODO: implement BST index
return search_node_;
}
Node* AdvancingFront::LocatePoint(const Point* point)
{
const double px = point->x;
Node* node = FindSearchNode(px);
const double nx = node->point->x;
if (px == nx) {
if (point != node->point) {
// We might have two nodes with same x value for a short time
if (point == node->prev->point) {
node = node->prev;
} else if (point == node->next->point) {
node = node->next;
} else {
assert(0);
}
}
} else if (px < nx) {
while ((node = node->prev) != NULL) {
if (point == node->point) {
break;
}
}
} else {
while ((node = node->next) != NULL) {
if (point == node->point)
break;
}
}
if(node) search_node_ = node;
return node;
}
AdvancingFront::~AdvancingFront()
{
}
}

118
polygon/poly2tri/sweep/advancing_front.h
View File

@ -1,118 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ADVANCED_FRONT_H
#define ADVANCED_FRONT_H
#include "../common/shapes.h"
namespace p2t {
struct Node;
// Advancing front node
struct Node {
Point* point;
Triangle* triangle;
Node* next;
Node* prev;
double value;
Node(Point& p) : point(&p), triangle(NULL), next(NULL), prev(NULL), value(p.x)
{
}
Node(Point& p, Triangle& t) : point(&p), triangle(&t), next(NULL), prev(NULL), value(p.x)
{
}
};
// Advancing front
class AdvancingFront {
public:
AdvancingFront(Node& head, Node& tail);
// Destructor
~AdvancingFront();
Node* head();
void set_head(Node* node);
Node* tail();
void set_tail(Node* node);
Node* search();
void set_search(Node* node);
/// Locate insertion point along advancing front
Node* LocateNode(const double& x);
Node* LocatePoint(const Point* point);
private:
Node* head_, *tail_, *search_node_;
Node* FindSearchNode(const double& x);
};
inline Node* AdvancingFront::head()
{
return head_;
}
inline void AdvancingFront::set_head(Node* node)
{
head_ = node;
}
inline Node* AdvancingFront::tail()
{
return tail_;
}
inline void AdvancingFront::set_tail(Node* node)
{
tail_ = node;
}
inline Node* AdvancingFront::search()
{
return search_node_;
}
inline void AdvancingFront::set_search(Node* node)
{
search_node_ = node;
}
}
#endif

72
polygon/poly2tri/sweep/cdt.cc
View File

@ -1,72 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "cdt.h"
namespace p2t {
CDT::CDT(std::vector<Point*> polyline)
{
sweep_context_ = new SweepContext(polyline);
sweep_ = new Sweep;
}
void CDT::AddHole(std::vector<Point*> polyline)
{
sweep_context_->AddHole(polyline);
}
void CDT::AddPoint(Point* point) {
sweep_context_->AddPoint(point);
}
void CDT::Triangulate()
{
sweep_->Triangulate(*sweep_context_);
}
std::vector<p2t::Triangle*> CDT::GetTriangles()
{
return sweep_context_->GetTriangles();
}
std::list<p2t::Triangle*> CDT::GetMap()
{
return sweep_context_->GetMap();
}
CDT::~CDT()
{
delete sweep_context_;
delete sweep_;
}
}

105
polygon/poly2tri/sweep/cdt.h
View File

@ -1,105 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CDT_H
#define CDT_H
#include "advancing_front.h"
#include "sweep_context.h"
#include "sweep.h"
/**
*
* @author Mason Green <mason.green@gmail.com>
*
*/
namespace p2t {
class CDT
{
public:
/**
* Constructor - add polyline with non repeating points
*
* @param polyline
*/
CDT(std::vector<Point*> polyline);
/**
* Destructor - clean up memory
*/
~CDT();
/**
* Add a hole
*
* @param polyline
*/
void AddHole(std::vector<Point*> polyline);
/**
* Add a steiner point
*
* @param point
*/
void AddPoint(Point* point);
/**
* Triangulate - do this AFTER you've added the polyline, holes, and Steiner points
*/
void Triangulate();
/**
* Get CDT triangles
*/
std::vector<Triangle*> GetTriangles();
/**
* Get triangle map
*/
std::list<Triangle*> GetMap();
private:
/**
* Internals
*/
SweepContext* sweep_context_;
Sweep* sweep_;
};
}
#endif

817
polygon/poly2tri/sweep/sweep.cc
View File

@ -1,817 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdexcept>
#include "sweep.h"
#include "sweep_context.h"
#include "advancing_front.h"
#include "../common/utils.h"
namespace p2t {
// Triangulate simple polygon with holes
void Sweep::Triangulate(SweepContext& tcx)
{
tcx.InitTriangulation();
tcx.CreateAdvancingFront(nodes_);
// Sweep points; build mesh
SweepPoints(tcx);
// Clean up
FinalizationPolygon(tcx);
}
void Sweep::SweepPoints(SweepContext& tcx)
{
for (int i = 1; i < tcx.point_count(); i++) {
Point& point = *tcx.GetPoint(i);
Node* node = &PointEvent(tcx, point);
for (unsigned int i = 0; i < point.edge_list.size(); i++) {
EdgeEvent(tcx, point.edge_list[i], node);
}
}
}
void Sweep::FinalizationPolygon(SweepContext& tcx)
{
// Get an Internal triangle to start with
Triangle* t = tcx.front()->head()->next->triangle;
Point* p = tcx.front()->head()->next->point;
while (!t->GetConstrainedEdgeCW(*p)) {
t = t->NeighborCCW(*p);
}
// Collect interior triangles constrained by edges
tcx.MeshClean(*t);
}
Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
{
Node& node = tcx.LocateNode(point);
Node& new_node = NewFrontTriangle(tcx, point, node);
// Only need to check +epsilon since point never have smaller
// x value than node due to how we fetch nodes from the front
if (point.x <= node.point->x + EPSILON) {
Fill(tcx, node);
}
//tcx.AddNode(new_node);
FillAdvancingFront(tcx, new_node);
return new_node;
}
void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node* node)
{
tcx.edge_event.constrained_edge = edge;
tcx.edge_event.right = (edge->p->x > edge->q->x);
if (IsEdgeSideOfTriangle(*node->triangle, *edge->p, *edge->q)) {
return;
}
// For now we will do all needed filling
// TODO: integrate with flip process might give some better performance
// but for now this avoid the issue with cases that needs both flips and fills
FillEdgeEvent(tcx, edge, node);
EdgeEvent(tcx, *edge->p, *edge->q, node->triangle, *edge->q);
}
void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point)
{
if (IsEdgeSideOfTriangle(*triangle, ep, eq)) {
return;
}
Point* p1 = triangle->PointCCW(point);
Orientation o1 = Orient2d(eq, *p1, ep);
if (o1 == COLLINEAR) {
if( triangle->Contains(&eq, p1)) {
triangle->MarkConstrainedEdge(&eq, p1 );
// We are modifying the constraint maybe it would be better to
// not change the given constraint and just keep a variable for the new constraint
tcx.edge_event.constrained_edge->q = p1;
triangle = &triangle->NeighborAcross(point);
EdgeEvent( tcx, ep, *p1, triangle, *p1 );
} else {
std::runtime_error("EdgeEvent - collinear points not supported");
assert(0);
}
return;
}
Point* p2 = triangle->PointCW(point);
Orientation o2 = Orient2d(eq, *p2, ep);
if (o2 == COLLINEAR) {
if( triangle->Contains(&eq, p2)) {
triangle->MarkConstrainedEdge(&eq, p2 );
// We are modifying the constraint maybe it would be better to
// not change the given constraint and just keep a variable for the new constraint
tcx.edge_event.constrained_edge->q = p2;
triangle = &triangle->NeighborAcross(point);
EdgeEvent( tcx, ep, *p2, triangle, *p2 );
} else {
std::runtime_error("EdgeEvent - collinear points not supported");
assert(0);
}
return;
}
if (o1 == o2) {
// Need to decide if we are rotating CW or CCW to get to a triangle
// that will cross edge
if (o1 == CW) {
triangle = triangle->NeighborCCW(point);
} else{
triangle = triangle->NeighborCW(point);
}
EdgeEvent(tcx, ep, eq, triangle, point);
} else {
// This triangle crosses constraint so lets flippin start!
FlipEdgeEvent(tcx, ep, eq, triangle, point);
}
}
bool Sweep::IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq)
{
int index = triangle.EdgeIndex(&ep, &eq);
if (index != -1) {
triangle.MarkConstrainedEdge(index);
Triangle* t = triangle.GetNeighbor(index);
if (t) {
t->MarkConstrainedEdge(&ep, &eq);
}
return true;
}
return false;
}
Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node)
{
Triangle* triangle = new Triangle(point, *node.point, *node.next->point);
triangle->MarkNeighbor(*node.triangle);
tcx.AddToMap(triangle);
Node* new_node = new Node(point);
nodes_.push_back(new_node);
new_node->next = node.next;
new_node->prev = &node;
node.next->prev = new_node;
node.next = new_node;
if (!Legalize(tcx, *triangle)) {
tcx.MapTriangleToNodes(*triangle);
}
return *new_node;
}
void Sweep::Fill(SweepContext& tcx, Node& node)
{
Triangle* triangle = new Triangle(*node.prev->point, *node.point, *node.next->point);
// TODO: should copy the constrained_edge value from neighbor triangles
// for now constrained_edge values are copied during the legalize
triangle->MarkNeighbor(*node.prev->triangle);
triangle->MarkNeighbor(*node.triangle);
tcx.AddToMap(triangle);
// Update the advancing front
node.prev->next = node.next;
node.next->prev = node.prev;
// If it was legalized the triangle has already been mapped
if (!Legalize(tcx, *triangle)) {
tcx.MapTriangleToNodes(*triangle);
}
}
void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
{
// Fill right holes
Node* node = n.next;
while (node->next) {
// if HoleAngle exceeds 90 degrees then break.
if (LargeHole_DontFill(node)) break;
Fill(tcx, *node);
node = node->next;
}
// Fill left holes
node = n.prev;
while (node->prev) {
// if HoleAngle exceeds 90 degrees then break.
if (LargeHole_DontFill(node)) break;
Fill(tcx, *node);
node = node->prev;
}
// Fill right basins
if (n.next && n.next->next) {
double angle = BasinAngle(n);
if (angle < PI_3div4) {
FillBasin(tcx, n);
}
}
}
// True if HoleAngle exceeds 90 degrees.
bool Sweep::LargeHole_DontFill(Node* node) {
Node* nextNode = node->next;
Node* prevNode = node->prev;
if (!AngleExceeds90Degrees(node->point, nextNode->point, prevNode->point))
return false;
// Check additional points on front.
Node* next2Node = nextNode->next;
// "..Plus.." because only want angles on same side as point being added.
if ((next2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point))
return false;
Node* prev2Node = prevNode->prev;
// "..Plus.." because only want angles on same side as point being added.
if ((prev2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point))
return false;
return true;
}
bool Sweep::AngleExceeds90Degrees(Point* origin, Point* pa, Point* pb) {
double angle = Angle(*origin, *pa, *pb);
bool exceeds90Degrees = ((angle > PI_div2) || (angle < -PI_div2));
return exceeds90Degrees;
}
bool Sweep::AngleExceedsPlus90DegreesOrIsNegative(Point* origin, Point* pa, Point* pb) {
double angle = Angle(*origin, *pa, *pb);
bool exceedsPlus90DegreesOrIsNegative = (angle > PI_div2) || (angle < 0);
return exceedsPlus90DegreesOrIsNegative;
}
double Sweep::Angle(Point& origin, Point& pa, Point& pb) {
/* Complex plane
* ab = cosA +i*sinA
* ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx)
* atan2(y,x) computes the principal value of the argument function
* applied to the complex number x+iy
* Where x = ax*bx + ay*by
* y = ax*by - ay*bx
*/
double px = origin.x;
double py = origin.y;
double ax = pa.x- px;
double ay = pa.y - py;
double bx = pb.x - px;
double by = pb.y - py;
double x = ax * by - ay * bx;
double y = ax * bx + ay * by;
double angle = atan2(x, y);
return angle;
}
double Sweep::BasinAngle(Node& node)
{
double ax = node.point->x - node.next->next->point->x;
double ay = node.point->y - node.next->next->point->y;
return atan2(ay, ax);
}
double Sweep::HoleAngle(Node& node)
{
/* Complex plane
* ab = cosA +i*sinA
* ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx)
* atan2(y,x) computes the principal value of the argument function
* applied to the complex number x+iy
* Where x = ax*bx + ay*by
* y = ax*by - ay*bx
*/
double ax = node.next->point->x - node.point->x;
double ay = node.next->point->y - node.point->y;
double bx = node.prev->point->x - node.point->x;
double by = node.prev->point->y - node.point->y;
return atan2(ax * by - ay * bx, ax * bx + ay * by);
}
bool Sweep::Legalize(SweepContext& tcx, Triangle& t)
{
// To legalize a triangle we start by finding if any of the three edges
// violate the Delaunay condition
for (int i = 0; i < 3; i++) {
if (t.delaunay_edge[i])
continue;
Triangle* ot = t.GetNeighbor(i);
if (ot) {
Point* p = t.GetPoint(i);
Point* op = ot->OppositePoint(t, *p);
int oi = ot->Index(op);
// If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
// then we should not try to legalize
if (ot->constrained_edge[oi] || ot->delaunay_edge[oi]) {
t.constrained_edge[i] = ot->constrained_edge[oi];
continue;
}
bool inside = Incircle(*p, *t.PointCCW(*p), *t.PointCW(*p), *op);
if (inside) {
// Lets mark this shared edge as Delaunay
t.delaunay_edge[i] = true;
ot->delaunay_edge[oi] = true;
// Lets rotate shared edge one vertex CW to legalize it
RotateTrianglePair(t, *p, *ot, *op);
// We now got one valid Delaunay Edge shared by two triangles
// This gives us 4 new edges to check for Delaunay
// Make sure that triangle to node mapping is done only one time for a specific triangle
bool not_legalized = !Legalize(tcx, t);
if (not_legalized) {
tcx.MapTriangleToNodes(t);
}
not_legalized = !Legalize(tcx, *ot);
if (not_legalized)
tcx.MapTriangleToNodes(*ot);
// Reset the Delaunay edges, since they only are valid Delaunay edges
// until we add a new triangle or point.
// XXX: need to think about this. Can these edges be tried after we
// return to previous recursive level?
t.delaunay_edge[i] = false;
ot->delaunay_edge[oi] = false;
// If triangle have been legalized no need to check the other edges since
// the recursive legalization will handles those so we can end here.
return true;
}
}
}
return false;
}
bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd)
{
double adx = pa.x - pd.x;
double ady = pa.y - pd.y;
double bdx = pb.x - pd.x;
double bdy = pb.y - pd.y;
double adxbdy = adx * bdy;
double bdxady = bdx * ady;
double oabd = adxbdy - bdxady;
if (oabd <= 0)
return false;
double cdx = pc.x - pd.x;
double cdy = pc.y - pd.y;
double cdxady = cdx * ady;
double adxcdy = adx * cdy;
double ocad = cdxady - adxcdy;
if (ocad <= 0)
return false;
double bdxcdy = bdx * cdy;
double cdxbdy = cdx * bdy;
double alift = adx * adx + ady * ady;
double blift = bdx * bdx + bdy * bdy;
double clift = cdx * cdx + cdy * cdy;
double det = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd;
return det > 0;
}
void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op)
{
Triangle* n1, *n2, *n3, *n4;
n1 = t.NeighborCCW(p);
n2 = t.NeighborCW(p);
n3 = ot.NeighborCCW(op);
n4 = ot.NeighborCW(op);
bool ce1, ce2, ce3, ce4;
ce1 = t.GetConstrainedEdgeCCW(p);
ce2 = t.GetConstrainedEdgeCW(p);
ce3 = ot.GetConstrainedEdgeCCW(op);
ce4 = ot.GetConstrainedEdgeCW(op);
bool de1, de2, de3, de4;
de1 = t.GetDelunayEdgeCCW(p);
de2 = t.GetDelunayEdgeCW(p);
de3 = ot.GetDelunayEdgeCCW(op);
de4 = ot.GetDelunayEdgeCW(op);
t.Legalize(p, op);
ot.Legalize(op, p);
// Remap delaunay_edge
ot.SetDelunayEdgeCCW(p, de1);
t.SetDelunayEdgeCW(p, de2);
t.SetDelunayEdgeCCW(op, de3);
ot.SetDelunayEdgeCW(op, de4);
// Remap constrained_edge
ot.SetConstrainedEdgeCCW(p, ce1);
t.SetConstrainedEdgeCW(p, ce2);
t.SetConstrainedEdgeCCW(op, ce3);
ot.SetConstrainedEdgeCW(op, ce4);
// Remap neighbors
// XXX: might optimize the markNeighbor by keeping track of
// what side should be assigned to what neighbor after the
// rotation. Now mark neighbor does lots of testing to find
// the right side.
t.ClearNeighbors();
ot.ClearNeighbors();
if (n1) ot.MarkNeighbor(*n1);
if (n2) t.MarkNeighbor(*n2);
if (n3) t.MarkNeighbor(*n3);
if (n4) ot.MarkNeighbor(*n4);
t.MarkNeighbor(ot);
}
void Sweep::FillBasin(SweepContext& tcx, Node& node)
{
if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
tcx.basin.left_node = node.next->next;
} else {
tcx.basin.left_node = node.next;
}
// Find the bottom and right node
tcx.basin.bottom_node = tcx.basin.left_node;
while (tcx.basin.bottom_node->next
&& tcx.basin.bottom_node->point->y >= tcx.basin.bottom_node->next->point->y) {
tcx.basin.bottom_node = tcx.basin.bottom_node->next;
}
if (tcx.basin.bottom_node == tcx.basin.left_node) {
// No valid basin
return;
}
tcx.basin.right_node = tcx.basin.bottom_node;
while (tcx.basin.right_node->next
&& tcx.basin.right_node->point->y < tcx.basin.right_node->next->point->y) {
tcx.basin.right_node = tcx.basin.right_node->next;
}
if (tcx.basin.right_node == tcx.basin.bottom_node) {
// No valid basins
return;
}
tcx.basin.width = tcx.basin.right_node->point->x - tcx.basin.left_node->point->x;
tcx.basin.left_highest = tcx.basin.left_node->point->y > tcx.basin.right_node->point->y;
FillBasinReq(tcx, tcx.basin.bottom_node);
}
void Sweep::FillBasinReq(SweepContext& tcx, Node* node)
{
// if shallow stop filling
if (IsShallow(tcx, *node)) {
return;
}
Fill(tcx, *node);
if (node->prev == tcx.basin.left_node && node->next == tcx.basin.right_node) {
return;
} else if (node->prev == tcx.basin.left_node) {
Orientation o = Orient2d(*node->point, *node->next->point, *node->next->next->point);
if (o == CW) {
return;
}
node = node->next;
} else if (node->next == tcx.basin.right_node) {
Orientation o = Orient2d(*node->point, *node->prev->point, *node->prev->prev->point);
if (o == CCW) {
return;
}
node = node->prev;
} else {
// Continue with the neighbor node with lowest Y value
if (node->prev->point->y < node->next->point->y) {
node = node->prev;
} else {
node = node->next;
}
}
FillBasinReq(tcx, node);
}
bool Sweep::IsShallow(SweepContext& tcx, Node& node)
{
double height;
if (tcx.basin.left_highest) {
height = tcx.basin.left_node->point->y - node.point->y;
} else {
height = tcx.basin.right_node->point->y - node.point->y;
}
// if shallow stop filling
if (tcx.basin.width > height) {
return true;
}
return false;
}
void Sweep::FillEdgeEvent(SweepContext& tcx, Edge* edge, Node* node)
{
if (tcx.edge_event.right) {
FillRightAboveEdgeEvent(tcx, edge, node);
} else {
FillLeftAboveEdgeEvent(tcx, edge, node);
}
}
void Sweep::FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node)
{
while (node->next->point->x < edge->p->x) {
// Check if next node is below the edge
if (Orient2d(*edge->q, *node->next->point, *edge->p) == CCW) {
FillRightBelowEdgeEvent(tcx, edge, *node);
} else {
node = node->next;
}
}
}
void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if (node.point->x < edge->p->x) {
if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
// Concave
FillRightConcaveEdgeEvent(tcx, edge, node);
} else{
// Convex
FillRightConvexEdgeEvent(tcx, edge, node);
// Retry this one
FillRightBelowEdgeEvent(tcx, edge, node);
}
}
}
void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
Fill(tcx, *node.next);
if (node.next->point != edge->p) {
// Next above or below edge?
if (Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) {
// Below
if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
// Next is concave
FillRightConcaveEdgeEvent(tcx, edge, node);
} else {
// Next is convex
}
}
}
}
void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
// Next concave or convex?
if (Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point) == CCW) {
// Concave
FillRightConcaveEdgeEvent(tcx, edge, *node.next);
} else{
// Convex
// Next above or below edge?
if (Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) {
// Below
FillRightConvexEdgeEvent(tcx, edge, *node.next);
} else{
// Above
}
}
}
void Sweep::FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node)
{
while (node->prev->point->x > edge->p->x) {
// Check if next node is below the edge
if (Orient2d(*edge->q, *node->prev->point, *edge->p) == CW) {
FillLeftBelowEdgeEvent(tcx, edge, *node);
} else {
node = node->prev;
}
}
}
void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if (node.point->x > edge->p->x) {
if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
// Concave
FillLeftConcaveEdgeEvent(tcx, edge, node);
} else {
// Convex
FillLeftConvexEdgeEvent(tcx, edge, node);
// Retry this one
FillLeftBelowEdgeEvent(tcx, edge, node);
}
}
}
void Sweep::FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
// Next concave or convex?
if (Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) {
// Concave
FillLeftConcaveEdgeEvent(tcx, edge, *node.prev);
} else{
// Convex
// Next above or below edge?
if (Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) {
// Below
FillLeftConvexEdgeEvent(tcx, edge, *node.prev);
} else{
// Above
}
}
}
void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
Fill(tcx, *node.prev);
if (node.prev->point != edge->p) {
// Next above or below edge?
if (Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) {
// Below
if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
// Next is concave
FillLeftConcaveEdgeEvent(tcx, edge, node);
} else{
// Next is convex
}
}
}
}
void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p)
{
Triangle& ot = t->NeighborAcross(p);
Point& op = *ot.OppositePoint(*t, p);
if (&ot == NULL) {
// If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here
//throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
assert(0);
}
if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) {
// Lets rotate shared edge one vertex CW
RotateTrianglePair(*t, p, ot, op);
tcx.MapTriangleToNodes(*t);
tcx.MapTriangleToNodes(ot);
if (p == eq && op == ep) {
if (eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) {
t->MarkConstrainedEdge(&ep, &eq);
ot.MarkConstrainedEdge(&ep, &eq);
Legalize(tcx, *t);
Legalize(tcx, ot);
} else {
// XXX: I think one of the triangles should be legalized here?
}
} else {
Orientation o = Orient2d(eq, op, ep);
t = &NextFlipTriangle(tcx, (int)o, *t, ot, p, op);
FlipEdgeEvent(tcx, ep, eq, t, p);
}
} else {
Point& newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, *t, ot, newP);
EdgeEvent(tcx, ep, eq, t, p);
}
}
Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op)
{
if (o == CCW) {
// ot is not crossing edge after flip
int edge_index = ot.EdgeIndex(&p, &op);
ot.delaunay_edge[edge_index] = true;
Legalize(tcx, ot);
ot.ClearDelunayEdges();
return t;
}
// t is not crossing edge after flip
int edge_index = t.EdgeIndex(&p, &op);
t.delaunay_edge[edge_index] = true;
Legalize(tcx, t);
t.ClearDelunayEdges();
return ot;
}
Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op)
{
Orientation o2d = Orient2d(eq, op, ep);
if (o2d == CW) {
// Right
return *ot.PointCCW(op);
} else if (o2d == CCW) {
// Left
return *ot.PointCW(op);
}
//throw new RuntimeException("[Unsupported] Opposing point on constrained edge");
assert(0);
// Never executed, due tu assert( 0 ). Just to avoid compil warning
return ep;
}
void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle,
Triangle& t, Point& p)
{
Triangle& ot = t.NeighborAcross(p);
Point& op = *ot.OppositePoint(t, p);
if (&t.NeighborAcross(p) == NULL) {
// If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here
//throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
assert(0);
}
if (InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW(eq), op)) {
// flip with new edge op->eq
FlipEdgeEvent(tcx, eq, op, &ot, op);
// TODO: Actually I just figured out that it should be possible to
// improve this by getting the next ot and op before the the above
// flip and continue the flipScanEdgeEvent here
// set new ot and op here and loop back to inScanArea test
// also need to set a new flip_triangle first
// Turns out at first glance that this is somewhat complicated
// so it will have to wait.
} else{
Point& newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP);
}
}
Sweep::~Sweep() {
// Clean up memory
for( unsigned i = 0; i < nodes_.size(); i++ )
{
delete nodes_[i];
}
}
}

284
polygon/poly2tri/sweep/sweep.h
View File

@ -1,284 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* Sweep-line, Constrained Delauney Triangulation (CDT) See: Domiter, V. and
* Zalik, B.(2008)'Sweep-line algorithm for constrained Delaunay triangulation',
* International Journal of Geographical Information Science
*
* "FlipScan" Constrained Edge Algorithm invented by Thomas Åhlén, thahlen@gmail.com
*/
#ifndef SWEEP_H
#define SWEEP_H
#include <vector>
namespace p2t {
class SweepContext;
struct Node;
struct Point;
struct Edge;
class Triangle;
class Sweep
{
public:
/**
* Triangulate
*
* @param tcx
*/
void Triangulate(SweepContext& tcx);
/**
* Destructor - clean up memory
*/
~Sweep();
private:
/**
* Start sweeping the Y-sorted point set from bottom to top
*
* @param tcx
*/
void SweepPoints(SweepContext& tcx);
/**
* Find closes node to the left of the new point and
* create a new triangle. If needed new holes and basins
* will be filled to.
*
* @param tcx
* @param point
* @return
*/
Node& PointEvent(SweepContext& tcx, Point& point);
/**
*
*
* @param tcx
* @param edge
* @param node
*/
void EdgeEvent(SweepContext& tcx, Edge* edge, Node* node);
void EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point);
/**
* Creates a new front triangle and legalize it
*
* @param tcx
* @param point
* @param node
* @return
*/
Node& NewFrontTriangle(SweepContext& tcx, Point& point, Node& node);
/**
* Adds a triangle to the advancing front to fill a hole.
* @param tcx
* @param node - middle node, that is the bottom of the hole
*/
void Fill(SweepContext& tcx, Node& node);
/**
* Returns true if triangle was legalized
*/
bool Legalize(SweepContext& tcx, Triangle& t);
/**
* <b>Requirement</b>:<br>
* 1. a,b and c form a triangle.<br>
* 2. a and d is know to be on opposite side of bc<br>
* <pre>
* a
* +
* / \
* / \
* b/ \c
* +-------+
* / d \
* / \
* </pre>
* <b>Fact</b>: d has to be in area B to have a chance to be inside the circle formed by
* a,b and c<br>
* d is outside B if orient2d(a,b,d) or orient2d(c,a,d) is CW<br>
* This preknowledge gives us a way to optimize the incircle test
* @param pa - triangle point, opposite d
* @param pb - triangle point
* @param pc - triangle point
* @param pd - point opposite a
* @return true if d is inside circle, false if on circle edge
*/
bool Incircle(Point& pa, Point& pb, Point& pc, Point& pd);
/**
* Rotates a triangle pair one vertex CW
*<pre>
* n2 n2
* P +-----+ P +-----+
* | t /| |\ t |
* | / | | \ |
* n1| / |n3 n1| \ |n3
* | / | after CW | \ |
* |/ oT | | oT \|
* +-----+ oP +-----+
* n4 n4
* </pre>
*/
void RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op);
/**
* Fills holes in the Advancing Front
*
*
* @param tcx
* @param n
*/
void FillAdvancingFront(SweepContext& tcx, Node& n);
// Decision-making about when to Fill hole.
// Contributed by ToolmakerSteve2
bool LargeHole_DontFill(Node* node);
bool AngleExceeds90Degrees(Point* origin, Point* pa, Point* pb);
bool AngleExceedsPlus90DegreesOrIsNegative(Point* origin, Point* pa, Point* pb);
double Angle(Point& origin, Point& pa, Point& pb);
/**
*
* @param node - middle node
* @return the angle between 3 front nodes
*/
double HoleAngle(Node& node);
/**
* The basin angle is decided against the horizontal line [1,0]
*/
double BasinAngle(Node& node);
/**
* Fills a basin that has formed on the Advancing Front to the right
* of given node.<br>
* First we decide a left,bottom and right node that forms the
* boundaries of the basin. Then we do a reqursive fill.
*
* @param tcx
* @param node - starting node, this or next node will be left node
*/
void FillBasin(SweepContext& tcx, Node& node);
/**
* Recursive algorithm to fill a Basin with triangles
*
* @param tcx
* @param node - bottom_node
*/
void FillBasinReq(SweepContext& tcx, Node* node);
bool IsShallow(SweepContext& tcx, Node& node);
bool IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq);
void FillEdgeEvent(SweepContext& tcx, Edge* edge, Node* node);
void FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node);
void FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node* node);
void FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p);
/**
* After a flip we have two triangles and know that only one will still be
* intersecting the edge. So decide which to contiune with and legalize the other
*
* @param tcx
* @param o - should be the result of an orient2d( eq, op, ep )
* @param t - triangle 1
* @param ot - triangle 2
* @param p - a point shared by both triangles
* @param op - another point shared by both triangles
* @return returns the triangle still intersecting the edge
*/
Triangle& NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op);
/**
* When we need to traverse from one triangle to the next we need
* the point in current triangle that is the opposite point to the next
* triangle.
*
* @param ep
* @param eq
* @param ot
* @param op
* @return
*/
Point& NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op);
/**
* Scan part of the FlipScan algorithm<br>
* When a triangle pair isn't flippable we will scan for the next
* point that is inside the flip triangle scan area. When found
* we generate a new flipEdgeEvent
*
* @param tcx
* @param ep - last point on the edge we are traversing
* @param eq - first point on the edge we are traversing
* @param flipTriangle - the current triangle sharing the point eq with edge
* @param t
* @param p
*/
void FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, Triangle& t, Point& p);
void FinalizationPolygon(SweepContext& tcx);
std::vector<Node*> nodes_;
};
}
#endif

216
polygon/poly2tri/sweep/sweep_context.cc
View File

@ -1,216 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "sweep_context.h"
#include <algorithm>
#include "advancing_front.h"
namespace p2t {
SweepContext::SweepContext(std::vector<Point*> polyline) :
front_(0),
head_(0),
tail_(0),
af_head_(0),
af_middle_(0),
af_tail_(0)
{
basin = Basin();
edge_event = EdgeEvent();
points_ = polyline;
InitEdges(points_);
}
void SweepContext::AddHole(std::vector<Point*> polyline)
{
InitEdges(polyline);
for(unsigned int i = 0; i < polyline.size(); i++) {
points_.push_back(polyline[i]);
}
}
void SweepContext::AddPoint(Point* point) {
points_.push_back(point);
}
std::vector<Triangle*> SweepContext::GetTriangles()
{
return triangles_;
}
std::list<Triangle*> SweepContext::GetMap()
{
return map_;
}
void SweepContext::InitTriangulation()
{
double xmax(points_[0]->x), xmin(points_[0]->x);
double ymax(points_[0]->y), ymin(points_[0]->y);
// Calculate bounds.
for (unsigned int i = 0; i < points_.size(); i++) {
Point& p = *points_[i];
if (p.x > xmax)
xmax = p.x;
if (p.x < xmin)
xmin = p.x;
if (p.y > ymax)
ymax = p.y;
if (p.y < ymin)
ymin = p.y;
}
double dx = kAlpha * (xmax - xmin);
double dy = kAlpha * (ymax - ymin);
head_ = new Point(xmax + dx, ymin - dy);
tail_ = new Point(xmin - dx, ymin - dy);
// Sort points along y-axis
std::sort(points_.begin(), points_.end(), cmp);
}
void SweepContext::InitEdges(std::vector<Point*> polyline)
{
int num_points = polyline.size();
for (int i = 0; i < num_points; i++) {
int j = i < num_points - 1 ? i + 1 : 0;
edge_list.push_back(new Edge(*polyline[i], *polyline[j]));
}
}
Point* SweepContext::GetPoint(const int& index)
{
return points_[index];
}
void SweepContext::AddToMap(Triangle* triangle)
{
map_.push_back(triangle);
}
Node& SweepContext::LocateNode(Point& point)
{
// TODO implement search tree
return *front_->LocateNode(point.x);
}
void SweepContext::CreateAdvancingFront(std::vector<Node*> nodes)
{
(void) nodes;
// Initial triangle
Triangle* triangle = new Triangle(*points_[0], *tail_, *head_);
map_.push_back(triangle);
af_head_ = new Node(*triangle->GetPoint(1), *triangle);
af_middle_ = new Node(*triangle->GetPoint(0), *triangle);
af_tail_ = new Node(*triangle->GetPoint(2));
front_ = new AdvancingFront(*af_head_, *af_tail_);
// TODO: More intuitive if head is middles next and not previous?
// so swap head and tail
af_head_->next = af_middle_;
af_middle_->next = af_tail_;
af_middle_->prev = af_head_;
af_tail_->prev = af_middle_;
}
void SweepContext::RemoveNode(Node* node)
{
delete node;
}
void SweepContext::MapTriangleToNodes(Triangle& t)
{
for (int i = 0; i < 3; i++) {
if (!t.GetNeighbor(i)) {
Node* n = front_->LocatePoint(t.PointCW(*t.GetPoint(i)));
if (n)
n->triangle = &t;
}
}
}
void SweepContext::RemoveFromMap(Triangle* triangle)
{
map_.remove(triangle);
}
void SweepContext::MeshClean(Triangle& triangle)
{
std::vector<Triangle *> triangles;
triangles.push_back(&triangle);
while(!triangles.empty()){
Triangle *t = triangles.back();
triangles.pop_back();
if (t != NULL && !t->IsInterior()) {
t->IsInterior(true);
triangles_.push_back(t);
for (int i = 0; i < 3; i++) {
if (!t->constrained_edge[i])
triangles.push_back(t->GetNeighbor(i));
}
}
}
}
SweepContext::~SweepContext()
{
// Clean up memory
delete head_;
delete tail_;
delete front_;
delete af_head_;
delete af_middle_;
delete af_tail_;
typedef std::list<Triangle*> type_list;
for(type_list::iterator iter = map_.begin(); iter != map_.end(); ++iter) {
Triangle* ptr = *iter;
delete ptr;
}
for(unsigned int i = 0; i < edge_list.size(); i++) {
delete edge_list[i];
}
}
}

186
polygon/poly2tri/sweep/sweep_context.h
View File

@ -1,186 +0,0 @@
/*
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SWEEP_CONTEXT_H
#define SWEEP_CONTEXT_H
#include <list>
#include <vector>
#include <cstddef>
namespace p2t {
// Inital triangle factor, seed triangle will extend 30% of
// PointSet width to both left and right.
const double kAlpha = 0.3;
struct Point;
class Triangle;
struct Node;
struct Edge;
class AdvancingFront;
class SweepContext {
public:
/// Constructor
SweepContext(std::vector<Point*> polyline);
/// Destructor
~SweepContext();
void set_head(Point* p1);
Point* head();
void set_tail(Point* p1);
Point* tail();
int point_count();
Node& LocateNode(Point& point);
void RemoveNode(Node* node);
void CreateAdvancingFront(std::vector<Node*> nodes);
/// Try to map a node to all sides of this triangle that don't have a neighbor
void MapTriangleToNodes(Triangle& t);
void AddToMap(Triangle* triangle);
Point* GetPoint(const int& index);
Point* GetPoints();
void RemoveFromMap(Triangle* triangle);
void AddHole(std::vector<Point*> polyline);
void AddPoint(Point* point);
AdvancingFront* front();
void MeshClean(Triangle& triangle);
std::vector<Triangle*> GetTriangles();
std::list<Triangle*> GetMap();
std::vector<Edge*> edge_list;
struct Basin {
Node* left_node;
Node* bottom_node;
Node* right_node;
double width;
bool left_highest;
Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL), width(0.0), left_highest(false)
{
}
void Clear()
{
left_node = NULL;
bottom_node = NULL;
right_node = NULL;
width = 0.0;
left_highest = false;
}
};
struct EdgeEvent {
Edge* constrained_edge;
bool right;
EdgeEvent() : constrained_edge(NULL), right(false)
{
}
};
Basin basin;
EdgeEvent edge_event;
private:
friend class Sweep;
std::vector<Triangle*> triangles_;
std::list<Triangle*> map_;
std::vector<Point*> points_;
// Advancing front
AdvancingFront* front_;
// head point used with advancing front
Point* head_;
// tail point used with advancing front
Point* tail_;
Node *af_head_, *af_middle_, *af_tail_;
void InitTriangulation();
void InitEdges(std::vector<Point*> polyline);
};
inline AdvancingFront* SweepContext::front()
{
return front_;
}
inline int SweepContext::point_count()
{
return points_.size();
}
inline void SweepContext::set_head(Point* p1)
{
head_ = p1;
}
inline Point* SweepContext::head()
{
return head_;
}
inline void SweepContext::set_tail(Point* p1)
{
tail_ = p1;
}
inline Point* SweepContext::tail()
{
return tail_;
}
}
#endif

89
polygon/polygons_defs.h
View File

@ -1,89 +0,0 @@
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2012-2014 Jean-Pierre Charras, jp.charras at wanadoo.fr
* Copyright (C) 2012-2014 KiCad Developers, see CHANGELOG.TXT for contributors.
*
* This program 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 program 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 this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/*
* file polygons_defs.h
* definitions to use boost::polygon in KiCad.
*/
#ifndef _POLYGONS_DEFS_H_
#define _POLYGONS_DEFS_H_
#include <boost/polygon/polygon.hpp>
// Define some types used here from boost::polygon
namespace bpl = boost::polygon; // bpl = boost polygon library
using namespace bpl::operators; // +, -, =, ...
// Definitions needed by boost::polygon
typedef int coordinate_type;
/**
* KI_POLYGON defines a single polygon ( boost::polygon_data type.
* When holes are created in a KPolygon, they are
* linked to main outline by overlapping segments,
* so there is always one polygon and one list of corners
* coordinates are int
*/
typedef bpl::polygon_data<int> KI_POLYGON;
/**
* KI_POLYGON_SET defines a set of single KI_POLYGON.
* A KI_POLYGON_SET is used to store a set of polygons
* when performing operations between 2 polygons
* or 2 sets of polygons
* The result of operations like and, xor... between 2 polygons
* is always stored in a KI_POLYGON_SET, because these operations
* can create many polygons
*/
typedef std::vector<KI_POLYGON> KI_POLYGON_SET;
/**
* KI_POLY_POINT defines a point for boost::polygon.
* KI_POLY_POINT store x and y coordinates (int)
*/
typedef bpl::point_data<int> KI_POLY_POINT;
/**
* KI_POLYGON_WITH_HOLES defines a single polygon with holes
* When holes are created in a KI_POLYGON_WITH_HOLES, they are
* stored as separate single polygons,
* KI_POLYGON_WITH_HOLES store always one polygon for the external outline
* and one list of polygons (holes) which can be empty
*/
typedef bpl::polygon_with_holes_data<int> KI_POLYGON_WITH_HOLES;
/**
* KI_POLYGON_WITH_HOLES_SET defines a set of KI_POLYGON_WITH_HOLES.
* A KI_POLYGON_WITH_HOLES_SET is used to store a set of polygons with holes
* when performing operations between 2 polygons
* or 2 sets of polygons with holes
* The result of operations like and, xor... between 2 polygons with holes
* is always stored in a KI_POLYGON_WITH_HOLES_SET, because these operations
* can create many separate polygons with holespolygons
*/
typedef std::vector<KI_POLYGON_WITH_HOLES> KI_POLYGON_WITH_HOLES_SET;
#endif // #ifndef _POLYGONS_DEFS_H_