kicad/qa/data/fixtures_geometry.h

242 lines
8.0 KiB
C++

/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
* Copyright (C) 2017 CERN
* @author Alejandro García Montoro <alejandro.garciamontoro@gmail.com>
*
* 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
*/
#ifndef __FIXTURES_H
#define __FIXTURES_H
#include <geometry/shape_poly_set.h>
#include <geometry/shape_line_chain.h>
/**
* Common data for the tests:
* 1. holeyPolySet: A polyset containing one single squared outline with two holes: a
* non-convex pentagon and a triangle.
* 2.solidPolySet: A polyset with three empty outlines and no holes.
* 3. uniqueVertexPolySet: A polyset with one single outline that contains just one vertex.
* 4. emptyPolySet: A polyset with no outlines.
*/
struct CommonTestData
{
// Polygon sets common for all the tests
SHAPE_POLY_SET emptyPolySet;
SHAPE_POLY_SET uniqueVertexPolySet;
SHAPE_POLY_SET solidPolySet;
SHAPE_POLY_SET holeyPolySet;
// Vectors containing the information with which the polygons are populated.
std::vector<VECTOR2I> uniquePoints;
std::vector<VECTOR2I> holeyPoints;
std::vector<SEG> holeySegments;
/**
* Constructor.
*/
CommonTestData()
{
// UniqueVertexPolySet shall have a unique vertex
uniquePoints.push_back( VECTOR2I( 100, 50 ) );
// Populate the holey polygon set points with 12 points
// Square
holeyPoints.push_back( VECTOR2I( 100,100 ) );
holeyPoints.push_back( VECTOR2I( 0,100 ) );
holeyPoints.push_back( VECTOR2I( 0,0 ) );
holeyPoints.push_back( VECTOR2I( 100,0 ) );
// Pentagon
holeyPoints.push_back( VECTOR2I( 10,10 ) );
holeyPoints.push_back( VECTOR2I( 10,20 ) );
holeyPoints.push_back( VECTOR2I( 15,15 ) );
holeyPoints.push_back( VECTOR2I( 20,20 ) );
holeyPoints.push_back( VECTOR2I( 20,10 ) );
// Triangle
holeyPoints.push_back( VECTOR2I( 40,10 ) );
holeyPoints.push_back( VECTOR2I( 40,20 ) );
holeyPoints.push_back( VECTOR2I( 60,10 ) );
// Save the segments of the holeyPolySet.
holeySegments.push_back( SEG( holeyPoints[0], holeyPoints[1] ) );
holeySegments.push_back( SEG( holeyPoints[1], holeyPoints[2] ) );
holeySegments.push_back( SEG( holeyPoints[2], holeyPoints[3] ) );
holeySegments.push_back( SEG( holeyPoints[3], holeyPoints[0] ) );
// Pentagon segments
holeySegments.push_back( SEG( holeyPoints[4], holeyPoints[5] ) );
holeySegments.push_back( SEG( holeyPoints[5], holeyPoints[6] ) );
holeySegments.push_back( SEG( holeyPoints[6], holeyPoints[7] ) );
holeySegments.push_back( SEG( holeyPoints[7], holeyPoints[8] ) );
holeySegments.push_back( SEG( holeyPoints[8], holeyPoints[4] ) );
// Triangle segments
holeySegments.push_back( SEG( holeyPoints[ 9], holeyPoints[10] ) );
holeySegments.push_back( SEG( holeyPoints[10], holeyPoints[11] ) );
holeySegments.push_back( SEG( holeyPoints[11], holeyPoints[9] ) );
// Auxiliary variables to store the contours that will be added to the polygons
SHAPE_LINE_CHAIN polyLine, hole;
// Create a polygon set with a unique vertex
polyLine.Append( uniquePoints[0] );
polyLine.SetClosed( true );
uniqueVertexPolySet.AddOutline(polyLine);
// Create a polygon set without holes
solidPolySet.NewOutline();
solidPolySet.NewOutline();
solidPolySet.NewOutline();
// Create a polygon set with holes
// Adds a new squared outline
polyLine.Clear();
for( int i = 0; i < 4; i++ )
polyLine.Append( holeyPoints[i] );
polyLine.SetClosed( true );
holeyPolySet.AddOutline(polyLine);
// Adds a new hole (a pentagon)
for( int i = 4; i < 9; i++ )
hole.Append( holeyPoints[i] );
hole.SetClosed( true );
holeyPolySet.AddHole( hole );
// Adds a new hole (a triangle)
hole.Clear();
for( int i = 9; i < 12; i++ )
hole.Append( holeyPoints[i] );
hole.SetClosed( true );
holeyPolySet.AddHole( hole );
}
~CommonTestData(){}
};
/**
* Fixture for the Collision test suite. It contains an instance of the common data and two
* vectors containing colliding and non-colliding points.
*/
struct CollisionFixture {
// Structure to store the common data.
struct CommonTestData common;
// Vectors containing colliding and non-colliding points
std::vector<VECTOR2I> collidingPoints, nonCollidingPoints;
/**
* Constructor
*/
CollisionFixture()
{
// Create points colliding with the poly set.
// Inside the polygon
collidingPoints.push_back( VECTOR2I( 10,90 ) );
// Inside the polygon, but on a re-entrant angle of a hole
collidingPoints.push_back( VECTOR2I( 15,16 ) );
// On a hole edge => inside the polygon
collidingPoints.push_back( VECTOR2I( 40,25 ) );
// On the outline edge => inside the polygon
collidingPoints.push_back( VECTOR2I( 0,10 ) );
// Create points not colliding with the poly set.
// Completely outside of the polygon
nonCollidingPoints.push_back( VECTOR2I( 200,200 ) );
// Inside the outline and inside a hole => outside the polygon
nonCollidingPoints.push_back( VECTOR2I( 15,12 ) );
}
~CollisionFixture(){}
};
/**
* Fixture for the Iterator test suite. It contains an instance of the common data, three polysets with null segments and a vector containing their points.
*/
struct IteratorFixture {
// Structure to store the common data.
struct CommonTestData common;
// Polygons to test whether the RemoveNullSegments method works
SHAPE_POLY_SET lastNullSegmentPolySet;
SHAPE_POLY_SET firstNullSegmentPolySet;
SHAPE_POLY_SET insideNullSegmentPolySet;
// Null segments points
std::vector<VECTOR2I> nullPoints;
IteratorFixture()
{
nullPoints.push_back( VECTOR2I( 100,100 ) );
nullPoints.push_back( VECTOR2I( 0,100 ) );
nullPoints.push_back( VECTOR2I( 0, 0 ) );
// Create a polygon with its last segment null
SHAPE_LINE_CHAIN polyLine;
polyLine.Append( nullPoints[0] );
polyLine.Append( nullPoints[1] );
polyLine.Append( nullPoints[2] );
polyLine.Append( nullPoints[2], true );
polyLine.SetClosed( true );
lastNullSegmentPolySet.AddOutline(polyLine);
// Create a polygon with its first segment null
polyLine.Clear();
polyLine.Append( nullPoints[0] );
polyLine.Append( nullPoints[0], true );
polyLine.Append( nullPoints[1] );
polyLine.Append( nullPoints[2] );
polyLine.SetClosed( true );
firstNullSegmentPolySet.AddOutline(polyLine);
// Create a polygon with an inside segment null
polyLine.Clear();
polyLine.Append( nullPoints[0] );
polyLine.Append( nullPoints[1] );
polyLine.Append( nullPoints[1], true );
polyLine.Append( nullPoints[2] );
polyLine.SetClosed( true );
insideNullSegmentPolySet.AddOutline(polyLine);
}
~IteratorFixture(){}
};
#endif //__FIXTURES_H