125 lines
5.0 KiB
C++
125 lines
5.0 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2022 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <qa_utils/wx_utils/unit_test_utils.h>
|
|
#include <geometry/ellipse.h>
|
|
#include <bezier_curves.h>
|
|
|
|
#include <fmt.h>
|
|
|
|
BOOST_AUTO_TEST_SUITE( EllipseToBezier )
|
|
|
|
|
|
/// Allows for rounding in the testcases
|
|
const double MAX_ERROR = 0.01;
|
|
|
|
|
|
struct ELLIPSE_TO_BEZIER_CASE
|
|
{
|
|
std::string name;
|
|
ELLIPSE<double> input;
|
|
std::vector<BEZIER<double>> expected;
|
|
};
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE( EllipseToBezier )
|
|
{
|
|
// This data mut be created "on the fly" to avoid a CTOR odres issue, because it uses
|
|
// static data like ANGLE_0 and it must be created **after** ANGLE_0 CTOR is called
|
|
// clang-format off
|
|
static const std::vector<ELLIPSE_TO_BEZIER_CASE> cases = {
|
|
{
|
|
"full circle",
|
|
{ { 0, 0 }, { 100, 0 }, 1.0, ANGLE_0, FULL_CIRCLE },
|
|
{ { { 100, 0 }, { 100, -55.22847498307934 }, { 55.228474983079344, -100 }, { 0, -100 } },
|
|
{ { 0, -100 }, { -55.22847498307934, -100 }, { -100, -55.228474983079344 }, { -100, 0 } },
|
|
{ { -100, 0 }, { -100, 55.22847498307934 }, { -55.228474983079344, 100 }, { 0, 100 } },
|
|
{ { 0, 100 }, { 55.22847498307934, 100 }, { 100, 55.228474983079344 }, { 100, 0 } }
|
|
}
|
|
},
|
|
{
|
|
"ellipse",
|
|
{ { 0, 0 }, { -100, 0 }, 0.5, ANGLE_0, FULL_CIRCLE },
|
|
{ { { -100, 0 }, { -100, 27.61423749153967 }, { -55.228474983079344, 50 }, { 0, 50 } },
|
|
{ { 0, 50 }, { 55.22847498307934, 50 }, { 100, 27.614237491539672 }, { 100, 0 } },
|
|
{ { 100, 0 }, { 100, -27.61423749153967 }, { 55.228474983079344, -50 }, { 0, -50 } },
|
|
{ { 0, -50 }, { -55.22847498307934, -50 }, { -100, -27.614237491539672 }, { -100, 0 } }
|
|
}
|
|
},
|
|
{
|
|
"arc1",
|
|
{ { 0, 0 }, { 100, 0 }, 0.5, ANGLE_180, FULL_CIRCLE },
|
|
{ { { -100, 0 }, { -100, 27.61423749153967 }, { -55.228474983079344, 50 }, { 0, 50 } },
|
|
{ { 0, 50 }, { 55.22847498307934, 50 }, { 100, 27.614237491539672 }, { 100, 0 } }
|
|
}
|
|
},
|
|
{
|
|
"arc2",
|
|
{ { 223, 165 }, { 372, 634 }, 0.96, EDA_ANGLE( 4.437, RADIANS_T ), EDA_ANGLE( 0.401, RADIANS_T ) },
|
|
{ { { -463.86, 336.27 }, { -389.81, 608.33 }, { -170.75, 818.49 }, { 99.52, 876.73 } },
|
|
{ { 99.52, 876.73 }, { 369.80, 934.98 }, { 643.36, 831.0 }, { 803.07, 609.31 } }
|
|
}
|
|
},
|
|
{
|
|
"arc3",
|
|
{ { 112.75, 490.24 }, { 304.54, 129.16 }, 7.14, EDA_ANGLE( 1.90, RADIANS_T ), EDA_ANGLE( 1.09, RADIANS_T ) },
|
|
{ { { 886.98, -1609.17 }, { 608.61, -1333.45 }, { 110.16, -394.92 }, { -305.88, 636.89 } },
|
|
{ { -305.88, 636.89 }, { -721.93, 1668.69 }, { -940.88, 2509.32 }, { -829.87, 2648.63 } },
|
|
{ { -829.87, 2648.63 }, { -718.85, 2787.95 }, { -308.47, 2187.55 }, { 152.23, 1211.78 } },
|
|
{ { 152.23, 1211.78 }, { 612.93, 236.01 }, { 996.95, -846.11 }, { 1071.24, -1377.92 } }
|
|
}
|
|
},
|
|
};
|
|
// clang-format on
|
|
|
|
for( const ELLIPSE_TO_BEZIER_CASE& c : cases )
|
|
{
|
|
BOOST_TEST_CONTEXT( c.name )
|
|
{
|
|
std::vector<BEZIER<double>> out;
|
|
TransformEllipseToBeziers<double>( c.input, out );
|
|
|
|
BOOST_CHECK_EQUAL( c.expected.size(), out.size() );
|
|
|
|
#if 0
|
|
for( BEZIER<double>& b : out )
|
|
{
|
|
BOOST_TEST_MESSAGE( fmt::format( "{{ {{ {}, {} }}, {{ {}, {} }}, {{ {}, {} }}, {{ {}, {} }} }}",
|
|
b.Start.x, b.Start.y, b.C1.x, b.C1.y,
|
|
b.C2.x, b.C2.y, b.End.x, b.End.y ) );
|
|
}
|
|
#endif
|
|
|
|
for( size_t i = 0; i < out.size(); i++ )
|
|
{
|
|
BOOST_CHECK_LE( ( c.expected[i].Start - out[i].Start ).EuclideanNorm(),
|
|
MAX_ERROR );
|
|
BOOST_CHECK_LE( ( c.expected[i].C1 - out[i].C1 ).EuclideanNorm(),
|
|
MAX_ERROR );
|
|
BOOST_CHECK_LE( ( c.expected[i].C2 - out[i].C2 ).EuclideanNorm(),
|
|
MAX_ERROR );
|
|
BOOST_CHECK_LE( ( c.expected[i].End - out[i].End ).EuclideanNorm(),
|
|
MAX_ERROR );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|