514 lines
16 KiB
C++
514 lines
16 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2019 KiCad Developers, see AUTHORS.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 test_array_options.cpp
|
|
* Test suite for #ARRAY_OPTIONS
|
|
*/
|
|
|
|
#include <qa_utils/geometry/geometry.h>
|
|
#include <qa_utils/wx_utils/unit_test_utils.h>
|
|
|
|
#include <base_units.h>
|
|
#include <trigo.h>
|
|
|
|
#include <array_options.h>
|
|
|
|
/**
|
|
* Define a stream function for logging this type.
|
|
*
|
|
* TODO: convert to boost_test_print_type when Boost minver > 1.64
|
|
*/
|
|
std::ostream& operator<<( std::ostream& os, const ARRAY_OPTIONS::TRANSFORM& aObj )
|
|
{
|
|
os << "TRANSFORM[ " << aObj.m_offset << " r " << aObj.m_rotation.AsDegrees() << "deg"
|
|
<< " ]";
|
|
return os;
|
|
}
|
|
|
|
|
|
/**
|
|
* Predicate to see if a #ARRAY_OPTIONS::TRANSFORM is equal or nearly equal
|
|
*/
|
|
bool TransformIsClose( const ARRAY_OPTIONS::TRANSFORM& aL, const ARRAY_OPTIONS::TRANSFORM& aR )
|
|
{
|
|
return KI_TEST::IsVecWithinTol<VECTOR2I>( aL.m_offset, aR.m_offset, 1 )
|
|
&& KI_TEST::IsWithin<double>( aL.m_rotation.AsDegrees(),
|
|
aR.m_rotation.AsDegrees(), 0.001 );
|
|
}
|
|
|
|
|
|
/**
|
|
* Generate all array transforms for an array descriptor and compare
|
|
* against a list of expected transforms
|
|
* @param aOpts the array descriptor
|
|
* @param aPos the position of the reference item
|
|
* @param aExp expected transform list
|
|
*/
|
|
void CheckArrayTransforms( const ARRAY_OPTIONS& aOpts, const VECTOR2I& aPos,
|
|
const std::vector<ARRAY_OPTIONS::TRANSFORM>& aExp )
|
|
{
|
|
std::vector<ARRAY_OPTIONS::TRANSFORM> transforms;
|
|
|
|
for( int i = 0; i < aOpts.GetArraySize(); ++i )
|
|
{
|
|
transforms.push_back( aOpts.GetTransform( i, aPos ) );
|
|
}
|
|
|
|
BOOST_CHECK_EQUAL( transforms.size(), aExp.size() );
|
|
|
|
for( unsigned i = 0; i < std::min( transforms.size(), aExp.size() ); ++i )
|
|
{
|
|
BOOST_TEST_CONTEXT( "Index " << i )
|
|
{
|
|
BOOST_CHECK_PREDICATE( TransformIsClose, ( transforms[i] )( aExp[i] ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Declare the test suite
|
|
*/
|
|
BOOST_AUTO_TEST_SUITE( ArrayOptions )
|
|
|
|
|
|
struct GRID_ARRAY_GEOM_PARAMS
|
|
{
|
|
int m_nx;
|
|
int m_ny;
|
|
VECTOR2I m_delta;
|
|
VECTOR2I m_offset;
|
|
int m_stagger;
|
|
bool m_stagger_by_row;
|
|
bool m_alternate_numbers;
|
|
bool m_h_then_v;
|
|
};
|
|
|
|
struct GRID_ARRAY_TEST_CASE
|
|
{
|
|
std::string m_case_name;
|
|
GRID_ARRAY_GEOM_PARAMS m_geom;
|
|
VECTOR2I m_item_pos;
|
|
std::vector<ARRAY_OPTIONS::TRANSFORM> m_exp_transforms;
|
|
};
|
|
|
|
|
|
// clang-format off
|
|
static const std::vector<GRID_ARRAY_TEST_CASE> grid_geom_cases = {
|
|
{
|
|
"2x3 rect grid",
|
|
{
|
|
2,
|
|
3,
|
|
{ schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) },
|
|
{ 0, 0 },
|
|
1,
|
|
true,
|
|
false,
|
|
true,
|
|
},
|
|
{ 0, 0 },
|
|
{
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"2x3 offset grid",
|
|
{
|
|
2,
|
|
3,
|
|
{ schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) },
|
|
{ schIUScale.mmToIU( 0.1 ), schIUScale.mmToIU( 0.2 ) },
|
|
1,
|
|
true,
|
|
false,
|
|
true,
|
|
},
|
|
{ 0, 0 },
|
|
{
|
|
// add the offsets for each positions
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 0.2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0.1 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2.1 ), schIUScale.mmToIU( 2.2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0.2 ), schIUScale.mmToIU( 4.0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2.2 ), schIUScale.mmToIU( 4.2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"2x3 stagger rows",
|
|
{
|
|
2,
|
|
3,
|
|
{ schIUScale.mmToIU( 3 ), schIUScale.mmToIU( 2 ) },
|
|
{ 0, 0 },
|
|
3,
|
|
true,
|
|
false,
|
|
true,
|
|
},
|
|
{ 0, 0 },
|
|
{
|
|
// add the offsets for each positions
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 3 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 1 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 4 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 5 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"2x3 stagger cols",
|
|
{
|
|
2,
|
|
3,
|
|
{ schIUScale.mmToIU( 3 ), schIUScale.mmToIU( 2 ) },
|
|
{ 0, 0 },
|
|
2,
|
|
false,
|
|
false,
|
|
true,
|
|
},
|
|
{ 0, 0 },
|
|
{
|
|
// add the offsets for each positions
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 3 ), schIUScale.mmToIU( 1 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 3 ), schIUScale.mmToIU( 3 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 3 ), schIUScale.mmToIU( 5 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"2x3 rect alternate",
|
|
{
|
|
2,
|
|
3,
|
|
{ schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) },
|
|
{ 0, 0 },
|
|
1,
|
|
true,
|
|
true,
|
|
true,
|
|
},
|
|
{ 0, 0 },
|
|
{
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"2x3 rect v then h",
|
|
{
|
|
2,
|
|
3,
|
|
{ schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) },
|
|
{ 0, 0 },
|
|
1,
|
|
true,
|
|
false,
|
|
false,
|
|
},
|
|
{ 0, 0 },
|
|
{
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 2 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( 2 ), schIUScale.mmToIU( 4 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
};
|
|
// clang-format on
|
|
|
|
|
|
/**
|
|
* Test of grid array geometry
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( GridGeometry )
|
|
{
|
|
for( const auto& c : grid_geom_cases )
|
|
{
|
|
BOOST_TEST_CONTEXT( c.m_case_name )
|
|
{
|
|
ARRAY_GRID_OPTIONS grid_opts;
|
|
|
|
grid_opts.m_nx = c.m_geom.m_nx;
|
|
grid_opts.m_ny = c.m_geom.m_ny;
|
|
grid_opts.m_delta = c.m_geom.m_delta;
|
|
grid_opts.m_offset = c.m_geom.m_offset;
|
|
grid_opts.m_stagger = c.m_geom.m_stagger;
|
|
grid_opts.m_stagger_rows = c.m_geom.m_stagger_by_row;
|
|
grid_opts.m_reverseNumberingAlternate = c.m_geom.m_alternate_numbers;
|
|
grid_opts.m_horizontalThenVertical = c.m_geom.m_h_then_v;
|
|
|
|
CheckArrayTransforms( grid_opts, c.m_item_pos, c.m_exp_transforms );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
struct CIRC_ARRAY_GEOM_PARAMS
|
|
{
|
|
int n;
|
|
double angle_offset;
|
|
VECTOR2I centre;
|
|
bool rotate;
|
|
};
|
|
|
|
struct CIRC_ARRAY_TEST_CASE
|
|
{
|
|
std::string m_case_name;
|
|
CIRC_ARRAY_GEOM_PARAMS m_geom;
|
|
VECTOR2I m_item_pos;
|
|
std::vector<ARRAY_OPTIONS::TRANSFORM> m_exp_transforms;
|
|
};
|
|
|
|
|
|
// clang-format off
|
|
static const std::vector<CIRC_ARRAY_TEST_CASE> circ_geom_cases = {
|
|
{
|
|
"Quad, no rotate items",
|
|
{
|
|
4,
|
|
0,
|
|
{ 0, 0 },
|
|
false,
|
|
},
|
|
{ schIUScale.mmToIU( 10 ), 0 },
|
|
{
|
|
// diamond shape
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( -10 ), schIUScale.mmToIU( -10 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( -20 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ {schIUScale.mmToIU( -10 ), schIUScale.mmToIU( 10 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"Quad, rotate items",
|
|
{
|
|
4,
|
|
0,
|
|
{ 0, 0 },
|
|
true,
|
|
},
|
|
{ schIUScale.mmToIU( 10 ), 0 },
|
|
{
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( -10 ), schIUScale.mmToIU( -10 ) }, EDA_ANGLE( 90.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( -20 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 180.0, DEGREES_T ) },
|
|
{ {schIUScale.mmToIU( -10 ), schIUScale.mmToIU( 10 ) }, EDA_ANGLE( 270.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
{
|
|
"Three pts, 90 deg angle",
|
|
{
|
|
3,
|
|
45.0,
|
|
{ 0, 0 },
|
|
true,
|
|
},
|
|
{ schIUScale.mmToIU( 10 ), 0 },
|
|
{
|
|
{ { schIUScale.mmToIU( 0 ), schIUScale.mmToIU( 0 ) }, EDA_ANGLE( 0.0, DEGREES_T ) },
|
|
// 10 * [ 1-sin(45), sin(45) ]
|
|
{ { schIUScale.mmToIU( -2.9289321881 ), schIUScale.mmToIU( -7.0710678118 ) }, EDA_ANGLE( 45.0, DEGREES_T ) },
|
|
{ { schIUScale.mmToIU( -10 ), schIUScale.mmToIU( -10 ) }, EDA_ANGLE( 90.0, DEGREES_T ) },
|
|
},
|
|
},
|
|
};
|
|
// clang-format on
|
|
|
|
/**
|
|
* Test of circular array geometry
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( CircularGeometry )
|
|
{
|
|
for( const auto& c : circ_geom_cases )
|
|
{
|
|
BOOST_TEST_CONTEXT( c.m_case_name )
|
|
{
|
|
ARRAY_CIRCULAR_OPTIONS grid_opts;
|
|
|
|
grid_opts.m_nPts = c.m_geom.n;
|
|
grid_opts.m_angle = EDA_ANGLE( c.m_geom.angle_offset, DEGREES_T );
|
|
grid_opts.m_centre = c.m_geom.centre;
|
|
grid_opts.m_rotateItems = c.m_geom.rotate;
|
|
|
|
CheckArrayTransforms( grid_opts, c.m_item_pos, c.m_exp_transforms );
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate all array names and check against expected
|
|
* @param aOpts the array descriptor
|
|
* @param aExp expected name list
|
|
*/
|
|
void CheckArrayNumbering( const ARRAY_OPTIONS& aOpts, const std::vector<std::string>& aExp )
|
|
{
|
|
std::vector<std::string> names;
|
|
|
|
for( int i = 0; i < aOpts.GetArraySize(); ++i )
|
|
{
|
|
names.push_back( aOpts.GetItemNumber( i ).ToStdString() );
|
|
}
|
|
|
|
BOOST_CHECK_EQUAL_COLLECTIONS( names.begin(), names.end(), aExp.begin(), aExp.end() );
|
|
}
|
|
|
|
|
|
struct GRID_ARRAY_NAMING_PARAMS
|
|
{
|
|
ARRAY_AXIS::NUMBERING_TYPE m_pri_type;
|
|
ARRAY_AXIS::NUMBERING_TYPE m_sec_type;
|
|
std::string m_start_at_x;
|
|
std::string m_start_at_y;
|
|
bool m_2d_numbering;
|
|
bool m_h_then_v;
|
|
int m_nx;
|
|
int m_ny;
|
|
};
|
|
|
|
|
|
struct GRID_ARRAY_NAMING_CASE
|
|
{
|
|
std::string m_case_name;
|
|
GRID_ARRAY_NAMING_PARAMS m_prms;
|
|
std::vector<std::string> m_exp_names;
|
|
};
|
|
|
|
|
|
// clang-format off
|
|
static const std::vector<GRID_ARRAY_NAMING_CASE> grid_name_cases = {
|
|
{
|
|
"Linear grid",
|
|
{
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_NUMERIC,
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_NUMERIC, // doesn't matter here
|
|
"1",
|
|
"2",
|
|
false,
|
|
false, // doesn't matter
|
|
2,
|
|
3,
|
|
},
|
|
{ "1", "2", "3", "4", "5", "6" },
|
|
},
|
|
{
|
|
// Tests a 2d grid
|
|
"2D grid A1",
|
|
{
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_ALPHA_FULL,
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_NUMERIC,
|
|
"A",
|
|
"1",
|
|
true,
|
|
true,
|
|
2,
|
|
3,
|
|
},
|
|
{ "A1", "B1", "A2", "B2", "A3", "B3" },
|
|
},
|
|
{
|
|
// Tests a 2d grid
|
|
"2D grid 11",
|
|
{
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_NUMERIC,
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_NUMERIC,
|
|
"1",
|
|
"1",
|
|
true,
|
|
false,
|
|
2,
|
|
3,
|
|
},
|
|
// moving down the "long axis" first
|
|
// so the first coordinate has a range of 1-3, the second 1-2
|
|
{ "11", "21", "31", "12", "22", "32" },
|
|
},
|
|
{
|
|
// Tests a 2d grid, with different types and offsets (and alphabet wrap)
|
|
"2D grid offsets",
|
|
{
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_NUMERIC,
|
|
ARRAY_AXIS::NUMBERING_TYPE::NUMBERING_ALPHA_FULL,
|
|
"5",
|
|
"Z",
|
|
true,
|
|
true,
|
|
2,
|
|
3,
|
|
},
|
|
{ "5Z", "6Z", "5AA", "6AA", "5AB", "6AB" },
|
|
},
|
|
};
|
|
// clang-format on
|
|
|
|
|
|
/**
|
|
* Test of grid array geometry
|
|
*/
|
|
BOOST_AUTO_TEST_CASE( GridNaming )
|
|
{
|
|
for( const auto& c : grid_name_cases )
|
|
{
|
|
BOOST_TEST_CONTEXT( c.m_case_name )
|
|
{
|
|
ARRAY_GRID_OPTIONS grid_opts;
|
|
|
|
grid_opts.m_nx = c.m_prms.m_nx;
|
|
grid_opts.m_ny = c.m_prms.m_ny;
|
|
|
|
grid_opts.m_horizontalThenVertical = c.m_prms.m_h_then_v;
|
|
|
|
grid_opts.m_pri_axis.SetAxisType( c.m_prms.m_pri_type );
|
|
grid_opts.m_sec_axis.SetAxisType( c.m_prms.m_sec_type );
|
|
|
|
grid_opts.m_pri_axis.SetOffset( c.m_prms.m_start_at_x );
|
|
grid_opts.m_sec_axis.SetOffset( c.m_prms.m_start_at_y );
|
|
|
|
grid_opts.m_2dArrayNumbering = c.m_prms.m_2d_numbering;
|
|
|
|
// other grid settings (geom) can be defaulted, as they don't affect numbering
|
|
|
|
CheckArrayNumbering( grid_opts, c.m_exp_names );
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|