doxygen/test__custom__pad__primitive__roundtrip_8cpp_source.html

/*

 * This program source code file is part of KiCad, a free EDA CAD application.

 *

 * Copyright The 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/file_utils.h>

#include <qa_utils/wx_utils/unit_test_utils.h>


#include <base_units.h>

#include <board.h>

#include <footprint.h>

#include <pad.h>

#include <pcb_point.h>

#include <pcb_shape.h>

#include <geometry/eda_angle.h>

#include <geometry/shape_line_chain.h>

#include <geometry/shape_poly_set.h>


#include <pcbnew_utils/board_file_utils.h>


#include <filesystem>

#include <memory>


BOOST_AUTO_TEST_SUITE( CustomPadPrimitiveRoundTrip )


namespace

{


int mm( double aMillimetres )

{

    return pcbIUScale.mmToIU( aMillimetres );

}


PCB_SHAPE* findPrimitive( const PAD* aPad, SHAPE_T aShape )

{

    for( const std::shared_ptr<PCB_SHAPE>& prim : aPad->GetPrimitives( PADSTACK::ALL_LAYERS ) )

    {

        if( prim->GetShape() == aShape )

            return prim.get();

    }


    return nullptr;

}


void checkPoly( const SHAPE_POLY_SET& aExpected, const SHAPE_POLY_SET& aGot )

{

    BOOST_REQUIRE_EQUAL( aExpected.OutlineCount(), aGot.OutlineCount() );


    const SHAPE_LINE_CHAIN& expOutline = aExpected.COutline( 0 );

    const SHAPE_LINE_CHAIN& gotOutline = aGot.COutline( 0 );


    BOOST_REQUIRE_EQUAL( expOutline.PointCount(), gotOutline.PointCount() );


    for( int ii = 0; ii < expOutline.PointCount(); ++ii )

    {

        BOOST_CHECK_EQUAL( gotOutline.CPoint( ii ).x, expOutline.CPoint( ii ).x );

        BOOST_CHECK_EQUAL( gotOutline.CPoint( ii ).y, expOutline.CPoint( ii ).y );

    }

}


} // namespace


BOOST_AUTO_TEST_CASE( BezierAndPolyOnTransformedFootprint )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );


    fp->SetReference( "U1" );


    // A non-cardinal rotation and an anisotropic scale make any spurious transform on

    // the primitives obvious.

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 25.0 ) ) );

    fp->SetOrientation( EDA_ANGLE( 30.0, DEGREES_T ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetPadstackMode( PADSTACK::MODE::NORMAL );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 1.0 ) ) );

    pad->SetAnchorPadShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );

    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CUSTOM );


    // Bezier primitive with deliberately asymmetric control points.

    PCB_SHAPE* bezier = new PCB_SHAPE( pad.get() );

    bezier->SetShape( SHAPE_T::BEZIER );

    bezier->SetStart( VECTOR2I( mm( 0.0 ), mm( 0.0 ) ) );

    bezier->SetBezierC1( VECTOR2I( mm( 1.0 ), mm( 2.0 ) ) );

    bezier->SetBezierC2( VECTOR2I( mm( 3.0 ), mm( -1.0 ) ) );

    bezier->SetEnd( VECTOR2I( mm( 4.0 ), mm( 0.5 ) ) );

    bezier->SetWidth( mm( 0.1 ) );

    pad->AddPrimitive( PADSTACK::ALL_LAYERS, bezier );


    // Polygon primitive with an asymmetric (non-rectangular) outline.

    SHAPE_LINE_CHAIN chain;

    chain.Append( VECTOR2I( mm( 1.0 ), mm( 0.0 ) ) );

    chain.Append( VECTOR2I( mm( 3.0 ), mm( 1.0 ) ) );

    chain.Append( VECTOR2I( mm( 2.0 ), mm( 4.0 ) ) );

    chain.Append( VECTOR2I( mm( -1.0 ), mm( 2.0 ) ) );

    chain.SetClosed( true );


    SHAPE_POLY_SET polySet;

    polySet.AddOutline( chain );


    PCB_SHAPE* poly = new PCB_SHAPE( pad.get() );

    poly->SetShape( SHAPE_T::POLY );

    poly->SetPolyShape( polySet );

    poly->SetWidth( mm( 0.1 ) );

    pad->AddPrimitive( PADSTACK::ALL_LAYERS, poly );


    // Capture the in-memory (pre-save) geometry as the round-trip reference.

    const VECTOR2I       expBezierStart = bezier->GetLibraryStart();

    const VECTOR2I       expBezierC1 = bezier->GetLibraryBezierC1();

    const VECTOR2I       expBezierC2 = bezier->GetLibraryBezierC2();

    const VECTOR2I       expBezierEnd = bezier->GetLibraryEnd();

    const int            expBezierWidth = bezier->GetWidth();

    const SHAPE_POLY_SET expPoly = poly->GetLibraryPolyShape();

    const int            expPolyWidth = poly->GetWidth();


    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_custom_pad_primitive_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );


    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    FOOTPRINT* fpFound = reloaded->Footprints().empty() ? nullptr : reloaded->Footprints().front();

    BOOST_REQUIRE_MESSAGE( fpFound, "Footprint not found in reloaded board" );

    BOOST_REQUIRE_MESSAGE( !fpFound->Pads().empty(), "Pad not found in reloaded footprint" );


    PAD* padFound = fpFound->Pads().front();


    PCB_SHAPE* bezierFound = findPrimitive( padFound, SHAPE_T::BEZIER );

    BOOST_REQUIRE_MESSAGE( bezierFound, "Bezier primitive not found in reloaded pad" );


    BOOST_CHECK_EQUAL( bezierFound->GetLibraryStart().x, expBezierStart.x );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryStart().y, expBezierStart.y );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryBezierC1().x, expBezierC1.x );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryBezierC1().y, expBezierC1.y );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryBezierC2().x, expBezierC2.x );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryBezierC2().y, expBezierC2.y );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryEnd().x, expBezierEnd.x );

    BOOST_CHECK_EQUAL( bezierFound->GetLibraryEnd().y, expBezierEnd.y );

    BOOST_CHECK_EQUAL( bezierFound->GetWidth(), expBezierWidth );


    PCB_SHAPE* polyFound = findPrimitive( padFound, SHAPE_T::POLY );

    BOOST_REQUIRE_MESSAGE( polyFound, "Polygon primitive not found in reloaded pad" );

    BOOST_REQUIRE( polyFound->IsPolyShapeValid() );


    checkPoly( expPoly, polyFound->GetLibraryPolyShape() );

    BOOST_CHECK_EQUAL( polyFound->GetWidth(), expPolyWidth );

}


BOOST_AUTO_TEST_CASE( SimplePadPrimitivesOnTransformedFootprint )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );


    fp->SetReference( "U1" );


    // A non-cardinal rotation and an anisotropic scale make any spurious transform on

    // the primitives obvious.

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 25.0 ) ) );

    fp->SetOrientation( EDA_ANGLE( 30.0, DEGREES_T ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetPadstackMode( PADSTACK::MODE::NORMAL );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 1.0 ) ) );

    pad->SetAnchorPadShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );

    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CUSTOM );


    PCB_SHAPE* seg = new PCB_SHAPE( pad.get() );

    seg->SetShape( SHAPE_T::SEGMENT );

    seg->SetStart( VECTOR2I( mm( 1.0 ), mm( 1.0 ) ) );

    seg->SetEnd( VECTOR2I( mm( 6.0 ), mm( 2.0 ) ) );

    seg->SetWidth( mm( 0.1 ) );

    pad->AddPrimitive( PADSTACK::ALL_LAYERS, seg );


    PCB_SHAPE* circle = new PCB_SHAPE( pad.get() );

    circle->SetShape( SHAPE_T::CIRCLE );

    circle->SetCenter( VECTOR2I( mm( 3.0 ), mm( 3.0 ) ) );

    circle->SetEnd( VECTOR2I( mm( 4.0 ), mm( 3.0 ) ) );

    circle->SetWidth( mm( 0.01 ) );

    pad->AddPrimitive( PADSTACK::ALL_LAYERS, circle );


    // Capture the in-memory (pre-save) geometry as the round-trip reference.

    const VECTOR2I       expSegStart = seg->GetLibraryStart();

    const VECTOR2I       expSegEnd = seg->GetLibraryEnd();

    const int            expSegWidth = seg->GetWidth();

    const VECTOR2I       expCircleCenter = circle->GetLibraryStart();

    const int            expCircleRadius = KiROUND( circle->GetStart().Distance( circle->GetEnd() ) );


    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_custom_pad_primitive_roundtrip2" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );


    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    FOOTPRINT* fpFound = reloaded->Footprints().empty() ? nullptr : reloaded->Footprints().front();

    BOOST_REQUIRE_MESSAGE( fpFound, "Footprint not found in reloaded board" );

    BOOST_REQUIRE_MESSAGE( !fpFound->Pads().empty(), "Pad not found in reloaded footprint" );


    PAD* padFound = fpFound->Pads().front();


    PCB_SHAPE* segFound = findPrimitive( padFound, SHAPE_T::SEGMENT );

    BOOST_REQUIRE_MESSAGE( segFound, "Segment primitive not found in reloaded pad" );


    BOOST_CHECK_EQUAL( segFound->GetLibraryStart().x, expSegStart.x );

    BOOST_CHECK_EQUAL( segFound->GetLibraryStart().y, expSegStart.y );

    BOOST_CHECK_EQUAL( segFound->GetLibraryEnd().x, expSegEnd.x );

    BOOST_CHECK_EQUAL( segFound->GetLibraryEnd().y, expSegEnd.y );

    BOOST_CHECK_EQUAL( segFound->GetWidth(), expSegWidth );


    PCB_SHAPE* circleFound = findPrimitive( padFound, SHAPE_T::ELLIPSE );

    BOOST_REQUIRE_MESSAGE( circleFound, "Elipse primitive not found in reloaded pad" );


    BOOST_CHECK_EQUAL( circleFound->GetLibraryStart().x, expCircleCenter.x );

    BOOST_CHECK_EQUAL( circleFound->GetLibraryStart().y, expCircleCenter.y );

    BOOST_CHECK_EQUAL( KiROUND( circleFound->GetStart().Distance( circleFound->GetEnd() ) ), expCircleRadius );

}


BOOST_AUTO_TEST_CASE( ScaledFootprintRoundTripStable )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );

    fp->SetReference( "U1" );

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 50.0 ) ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetPadstackMode( PADSTACK::MODE::NORMAL );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetLibSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 1.0 ) ) );

    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_scaled_fp_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );

    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    FOOTPRINT* r = reloaded->Footprints().front();

    BOOST_CHECK_CLOSE( r->GetScaleX(), 2.0, 1e-6 );

    BOOST_CHECK_CLOSE( r->GetScaleY(), 1.5, 1e-6 );

}


BOOST_AUTO_TEST_CASE( PadPositionAndOrientationRoundTripStable )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );

    fp->SetReference( "U1" );

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 50.0 ) ) );

    fp->SetOrientation( EDA_ANGLE( 30.0, DEGREES_T ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::RECTANGLE );

    pad->SetLibSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 0.5 ) ) );

    pad->SetPosition( VECTOR2I( mm( 53.0 ), mm( 51.0 ) ) );

    pad->SetOrientation( EDA_ANGLE( 75.0, DEGREES_T ) );

    PAD* padPtr = pad.get();

    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    const VECTOR2I  posBefore = padPtr->GetPosition();

    const EDA_ANGLE orientBefore = padPtr->GetOrientation();


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_pad_pos_orient_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );

    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    PAD* r = reloaded->Footprints().front()->Pads().front();

    BOOST_CHECK_EQUAL( r->GetPosition().x, posBefore.x );

    BOOST_CHECK_EQUAL( r->GetPosition().y, posBefore.y );

    BOOST_CHECK_CLOSE( r->GetOrientation().AsDegrees(), orientBefore.AsDegrees(), 1e-6 );

}


BOOST_AUTO_TEST_CASE( PadDeltaRoundTripStable )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );

    fp->SetReference( "U1" );

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 50.0 ) ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::TRAPEZOID );

    pad->SetLibSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 1.0 ) ) );

    pad->SetDelta( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 0.4 ), mm( 0.0 ) ) );

    PAD* padPtr = pad.get();

    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    const VECTOR2I before = padPtr->GetDelta( PADSTACK::ALL_LAYERS );


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_pad_delta_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );

    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    PAD* r = reloaded->Footprints().front()->Pads().front();

    BOOST_TEST_MESSAGE( "delta before: " << before.x << "," << before.y

                                         << " after: " << r->GetDelta( PADSTACK::ALL_LAYERS ).x << ","

                                         << r->GetDelta( PADSTACK::ALL_LAYERS ).y );

    BOOST_CHECK_EQUAL( r->GetDelta( PADSTACK::ALL_LAYERS ).x, before.x );

    BOOST_CHECK_EQUAL( r->GetDelta( PADSTACK::ALL_LAYERS ).y, before.y );

}


BOOST_AUTO_TEST_CASE( PadOffsetRoundTripStable )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );

    fp->SetReference( "U1" );

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 50.0 ) ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetPadstackMode( PADSTACK::MODE::NORMAL );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::RECTANGLE );

    pad->SetLibSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 1.0 ) ) );

    pad->SetLibOffset( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 0.3 ), mm( 0.2 ) ) );

    PAD* padPtr = pad.get();

    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    const VECTOR2I before = padPtr->GetOffset( PADSTACK::ALL_LAYERS );


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_pad_offset_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );

    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    PAD* r = reloaded->Footprints().front()->Pads().front();

    BOOST_TEST_MESSAGE( "offset before: " << before.x << "," << before.y

                                          << " after: " << r->GetOffset( PADSTACK::ALL_LAYERS ).x << ","

                                          << r->GetOffset( PADSTACK::ALL_LAYERS ).y );

    BOOST_CHECK_EQUAL( r->GetOffset( PADSTACK::ALL_LAYERS ).x, before.x );

    BOOST_CHECK_EQUAL( r->GetOffset( PADSTACK::ALL_LAYERS ).y, before.y );

}


BOOST_AUTO_TEST_CASE( FootprintPointRoundTripStable )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );

    fp->SetReference( "U1" );

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 50.0 ) ) );

    fp->SetOrientation( EDA_ANGLE( 30.0, DEGREES_T ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PCB_POINT> pt = std::make_unique<PCB_POINT>( fp.get() );

    pt->SetLayer( F_Cu );

    pt->SetPosition( VECTOR2I( mm( 55.0 ), mm( 52.0 ) ) );

    PCB_POINT* ptPtr = pt.get();

    fp->Add( pt.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    const VECTOR2I before = ptPtr->GetPosition();


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_fp_point_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );

    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    FOOTPRINT* r = reloaded->Footprints().front();

    BOOST_REQUIRE( !r->Points().empty() );

    PCB_POINT* rp = r->Points().front();

    BOOST_TEST_MESSAGE( "point before: " << before.x << "," << before.y << " after: " << rp->GetPosition().x << ","

                                         << rp->GetPosition().y );

    BOOST_CHECK_EQUAL( rp->GetPosition().x, before.x );

    BOOST_CHECK_EQUAL( rp->GetPosition().y, before.y );

}


BOOST_AUTO_TEST_CASE( RotatedPadSizeRoundTripStable )

{

    std::unique_ptr<BOARD>     board = std::make_unique<BOARD>();

    std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>( board.get() );

    fp->SetReference( "U1" );

    fp->SetPosition( VECTOR2I( mm( 50.0 ), mm( 50.0 ) ) );

    fp->SetTransformScale( 2.0, 1.5 );


    std::unique_ptr<PAD> pad = std::make_unique<PAD>( fp.get() );

    pad->SetPadstackMode( PADSTACK::MODE::NORMAL );

    pad->SetNumber( "1" );

    pad->SetAttribute( PAD_ATTRIB::SMD );

    pad->SetLayerSet( LSET( { F_Cu } ) );

    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::RECTANGLE );

    pad->SetLibSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 0.5 ) ) );

    pad->SetOrientation( EDA_ANGLE( 90.0, DEGREES_T ) );

    PAD* padPtr = pad.get();

    fp->Add( pad.release(), ADD_MODE::APPEND, true );

    board->Add( fp.release(), ADD_MODE::APPEND, true );


    const VECTOR2I boardSizeBefore = padPtr->GetSize( PADSTACK::ALL_LAYERS );


    KI_TEST::SCOPED_TEMP_DIR tmp( "kicad_qa_rotated_pad_roundtrip" );

    std::filesystem::path    boardFile = tmp.Path() / "board.kicad_pcb";


    KI_TEST::DumpBoardToFile( *board, boardFile );

    std::unique_ptr<BOARD> reloaded = KI_TEST::ReadBoardFromFile( boardFile );

    BOOST_REQUIRE( reloaded );


    PAD* r = reloaded->Footprints().front()->Pads().front();

    BOOST_CHECK_EQUAL( r->GetSize( PADSTACK::ALL_LAYERS ).x, boardSizeBefore.x );

    BOOST_CHECK_EQUAL( r->GetSize( PADSTACK::ALL_LAYERS ).y, boardSizeBefore.y );

}


// A footprint X-scale must stretch a pad along the footprint's X axis whatever the pad's

// own orientation, so the scale is conjugated into the pad frame (a 90deg pad swaps X/Y).


BOOST_AUTO_TEST_CASE( PadSizeScalesAlongFootprintAxisRegardlessOfPadOrientation )

{

    BOARD      board;

    FOOTPRINT* fp = new FOOTPRINT( &board );

    fp->SetPosition( VECTOR2I( 0, 0 ) );

    fp->SetOrientation( ANGLE_0 );

    board.Add( fp );


    auto makePad =

            [&]( const EDA_ANGLE& aRelOrient )

            {

                PAD* pad = new PAD( fp );

                pad->SetPadstackMode( PADSTACK::MODE::NORMAL );

                pad->SetAttribute( PAD_ATTRIB::SMD );

                pad->SetLayerSet( LSET( { F_Cu } ) );

                pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::RECTANGLE );

                pad->SetSize( PADSTACK::ALL_LAYERS, VECTOR2I( mm( 1.0 ), mm( 0.5 ) ) );

                pad->SetOrientation( aRelOrient );

                fp->Add( pad );

                return pad;

            };


    PAD* pad0 = makePad( ANGLE_0 );

    PAD* pad90 = makePad( EDA_ANGLE( 90.0, DEGREES_T ) );


    const int xBefore0 = pad0->GetBoundingBox().GetWidth();

    const int xBefore90 = pad90->GetBoundingBox().GetWidth();


    fp->SetTransformScale( 2.0, 1.0 );


    BOOST_CHECK_EQUAL( pad0->GetSize( PADSTACK::ALL_LAYERS ).x, mm( 2.0 ) );

    BOOST_CHECK_EQUAL( pad0->GetSize( PADSTACK::ALL_LAYERS ).y, mm( 0.5 ) );

    BOOST_CHECK_EQUAL( pad90->GetSize( PADSTACK::ALL_LAYERS ).x, mm( 1.0 ) );

    BOOST_CHECK_EQUAL( pad90->GetSize( PADSTACK::ALL_LAYERS ).y, mm( 1.0 ) );


    // Both pads double their board-X extent, regardless of orientation.

    BOOST_CHECK_EQUAL( pad0->GetBoundingBox().GetWidth(), 2 * xBefore0 );

    BOOST_CHECK_EQUAL( pad90->GetBoundingBox().GetWidth(), 2 * xBefore90 );

}


BOOST_AUTO_TEST_SUITE_END()

ALTIUM_RECORD::PAD
@ PAD
Definition altium_parser_pcb.h:142

base_units.h

pcbIUScale
constexpr EDA_IU_SCALE pcbIUScale
Definition base_units.h:128

BITMAPS::pad
@ pad
Definition bitmaps_list.h:425

board.h

board_file_utils.h
General utilities for PCB file IO for QA programs.

ADD_MODE::APPEND
@ APPEND
Definition board_item_container.h:31

KiROUND
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition box2.h:982

BOARD
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411

BOARD::Add
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition board.cpp:1520

BOX2::GetWidth
constexpr size_type GetWidth() const
Definition box2.h:211

EDA_ANGLE
Definition eda_angle.h:36

EDA_ANGLE::AsDegrees
double AsDegrees() const
Definition eda_angle.h:115

EDA_SHAPE::GetEnd
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
Definition eda_shape.h:333

EDA_SHAPE::GetStart
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
Definition eda_shape.h:283

EDA_SHAPE::IsPolyShapeValid
bool IsPolyShapeValid() const
Definition eda_shape.cpp:3086

FOOTPRINT
Definition footprint.h:265

FOOTPRINT::SetPosition
void SetPosition(const VECTOR2I &aPos) override
Definition footprint.cpp:3681

FOOTPRINT::Points
PCB_POINTS & Points()
Definition footprint.h:370

FOOTPRINT::SetOrientation
void SetOrientation(const EDA_ANGLE &aNewAngle)
Definition footprint.cpp:3793

FOOTPRINT::Pads
std::deque< PAD * > & Pads()
Definition footprint.h:355

FOOTPRINT::GetScaleX
double GetScaleX() const
Definition footprint.h:399

FOOTPRINT::SetTransformScale
void SetTransformScale(double aScaleX, double aScaleY)
Definition footprint.cpp:3630

FOOTPRINT::Add
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Adds an item to the container.
Definition footprint.cpp:1874

FOOTPRINT::GetScaleY
double GetScaleY() const
Definition footprint.h:400

KI_TEST::SCOPED_TEMP_DIR
Definition file_utils.h:38

KI_TEST::SCOPED_TEMP_DIR::Path
const std::filesystem::path & Path() const
Get the path to the temporary directory as a std::filesystem::path.
Definition file_utils.h:61

LSET
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37

PADSTACK::MODE::NORMAL
@ NORMAL
Shape is the same on all layers.
Definition padstack.h:170

PADSTACK::ALL_LAYERS
static constexpr PCB_LAYER_ID ALL_LAYERS
! The layer identifier to use for the single defintion on normal padstacks
Definition padstack.h:179

PAD
Definition pad.h:61

PAD::GetPrimitives
const std::vector< std::shared_ptr< PCB_SHAPE > > & GetPrimitives(PCB_LAYER_ID aLayer) const
Accessor to the basic shape list for custom-shaped pads.
Definition pad.h:375

PAD::GetBoundingBox
const BOX2I GetBoundingBox() const override
The bounding box is cached, so this will be efficient most of the time.
Definition pad.cpp:1673

PAD::GetDelta
const VECTOR2I & GetDelta(PCB_LAYER_ID aLayer) const
Definition pad.h:307

PAD::GetPosition
VECTOR2I GetPosition() const override
Definition pad.cpp:255

PAD::GetOffset
VECTOR2I GetOffset(PCB_LAYER_ID aLayer) const
Definition pad.cpp:837

PAD::GetSize
VECTOR2I GetSize(PCB_LAYER_ID aLayer) const
Definition pad.cpp:297

PAD::GetOrientation
EDA_ANGLE GetOrientation() const
Return the rotation angle of the pad.
Definition pad.cpp:1795

PCB_POINT
A PCB_POINT is a 0-dimensional point that is used to mark a position on a PCB, or more usually a foot...
Definition pcb_point.h:39

PCB_POINT::GetPosition
VECTOR2I GetPosition() const override
Definition pcb_point.h:60

PCB_SHAPE
Definition pcb_shape.h:35

PCB_SHAPE::SetBezierC1
void SetBezierC1(const VECTOR2I &aPt) override
Definition pcb_shape.cpp:1409

PCB_SHAPE::GetLibraryBezierC1
VECTOR2I GetLibraryBezierC1() const
Definition pcb_shape.cpp:1360

PCB_SHAPE::SetWidth
void SetWidth(int aWidth) override
Definition pcb_shape.cpp:1045

PCB_SHAPE::GetWidth
int GetWidth() const override
Definition pcb_shape.cpp:725

PCB_SHAPE::SetShape
void SetShape(SHAPE_T aShape) override
Definition pcb_shape.h:212

PCB_SHAPE::SetEnd
void SetEnd(const VECTOR2I &aEnd) override
Definition pcb_shape.cpp:1017

PCB_SHAPE::GetLibraryEnd
VECTOR2I GetLibraryEnd() const
Definition pcb_shape.h:233

PCB_SHAPE::SetPolyShape
void SetPolyShape(const SHAPE_POLY_SET &aShape) override
Definition pcb_shape.cpp:1423

PCB_SHAPE::GetLibraryStart
VECTOR2I GetLibraryStart() const
Definition pcb_shape.h:232

PCB_SHAPE::SetStart
void SetStart(const VECTOR2I &aStart) override
Definition pcb_shape.cpp:1010

PCB_SHAPE::SetBezierC2
void SetBezierC2(const VECTOR2I &aPt) override
Definition pcb_shape.cpp:1416

PCB_SHAPE::GetLibraryPolyShape
SHAPE_POLY_SET GetLibraryPolyShape() const
Definition pcb_shape.cpp:1384

PCB_SHAPE::GetLibraryBezierC2
VECTOR2I GetLibraryBezierC2() const
Definition pcb_shape.cpp:1372

SHAPE_LINE_CHAIN
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
Definition shape_line_chain.h:78

SHAPE_LINE_CHAIN::PointCount
int PointCount() const
Return the number of points (vertices) in this line chain.
Definition shape_line_chain.h:367

SHAPE_LINE_CHAIN::CPoint
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
Definition shape_line_chain.h:418

SHAPE_POLY_SET
Represent a set of closed polygons.
Definition shape_poly_set.h:67

SHAPE_POLY_SET::AddOutline
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new outline to the set and returns its index.
Definition shape_poly_set.cpp:559

SHAPE_POLY_SET::OutlineCount
int OutlineCount() const
Return the number of outlines in the set.
Definition shape_poly_set.h:729

SHAPE_POLY_SET::COutline
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
Definition shape_poly_set.h:798

VECTOR2::Distance
double Distance(const VECTOR2< extended_type > &aVector) const
Compute the distance between two vectors.
Definition vector2d.h:574

VECTOR2::x
T x
Definition vector2d.h:75

VECTOR2::y
T y
Definition vector2d.h:75

eda_angle.h

ANGLE_0
static constexpr EDA_ANGLE ANGLE_0
Definition eda_angle.h:448

DEGREES_T
@ DEGREES_T
Definition eda_angle.h:30

SHAPE_T
SHAPE_T
Definition eda_shape.h:54

SHAPE_T::CIRCLE
@ CIRCLE
Definition eda_shape.h:59

SHAPE_T::ELLIPSE
@ ELLIPSE
Definition eda_shape.h:62

SHAPE_T::SEGMENT
@ SEGMENT
Definition eda_shape.h:56

SHAPE_T::POLY
@ POLY
Definition eda_shape.h:60

SHAPE_T::BEZIER
@ BEZIER
Definition eda_shape.h:61

file_utils.h

footprint.h

F_Cu
@ F_Cu
Definition layer_ids.h:60

KI_TEST::ReadBoardFromFile
std::unique_ptr< BOARD > ReadBoardFromFile(const std::filesystem::path &aFilename)
Definition board_file_utils.cpp:122

KI_TEST::DumpBoardToFile
void DumpBoardToFile(BOARD &board, const std::filesystem::path &aFilename)
Utility function to simply write a Board out to a file.
Definition board_file_utils.cpp:66

pad.h

PAD_ATTRIB::SMD
@ SMD
Smd pad, appears on the solder paste layer (default)
Definition padstack.h:98

PAD_SHAPE::CIRCLE
@ CIRCLE
Definition padstack.h:52

PAD_SHAPE::TRAPEZOID
@ TRAPEZOID
Definition padstack.h:55

PAD_SHAPE::CUSTOM
@ CUSTOM
Definition padstack.h:60

PAD_SHAPE::RECTANGLE
@ RECTANGLE
Definition padstack.h:53

pcb_point.h

pcb_shape.h

PLUGIN_ACTION_SCOPE::FOOTPRINT
@ FOOTPRINT
Definition plugin_action_scope.h:30

shape_line_chain.h

shape_poly_set.h

BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(CadstarPartParser)

BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(BezierAndPolyOnTransformedFootprint)
A custom pad's bezier and polygon primitives must survive a save/reload unchanged,...
Definition test_custom_pad_primitive_roundtrip.cpp:89

BOOST_REQUIRE
BOOST_REQUIRE(intersection.has_value()==c.ExpectedIntersection.has_value())

BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()

chain
const SHAPE_LINE_CHAIN chain
Definition test_shape_arc.cpp:1232

circle
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)

BOOST_TEST_MESSAGE
BOOST_TEST_MESSAGE("Polyline has "<< chain.PointCount()<< " points")

BOOST_CHECK_EQUAL
BOOST_CHECK_EQUAL(result, "25.4")

unit_test_utils.h

VECTOR2I
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708