test_constraint_overlay.cpp

Go to the documentation of this file.

/*
 * 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 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, see <https://www.gnu.org/licenses/>.
 */

 
#include <qa_utils/wx_utils/unit_test_utils.h>
#include <pcbnew_utils/board_test_utils.h>
 
#include <algorithm>
#include <memory>
#include <set>
 
#include <board.h>
#include <footprint.h>
#include <math/box2.h>
#include <pcb_shape.h>
#include <settings/settings_manager.h>
#include <view/view.h>
 
#include <constraints/pcb_constraint.h>
#include <constraints/board_constraint_adapter.h>
#include <constraints/constraint_builder.h>
 
#include <tools/constraint_overlay.h>
 
BOOST_AUTO_TEST_SUITE( ConstraintOverlay )
 
 
BOOST_AUTO_TEST_CASE( OverlayRegistersOncePerLayerAndUnregistersFully )
{
    BOARD       board;
    KIGFX::VIEW view;
 
    BOX2I maxBox;
    maxBox.SetMaximum();
 
    std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> baseline;
    view.Query( maxBox, baseline );
 
    {
        CONSTRAINT_OVERLAY overlay( &board, &view );
 
        std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> withOverlay;
        view.Query( maxBox, withOverlay );
 
        // Each item may appear once per layer it occupies. A duplicate (item, layer) pair means
        // the same VIEW_ITEM was added to the view twice and can only be removed once.
        std::set<KIGFX::VIEW::LAYER_ITEM_PAIR> unique( withOverlay.begin(), withOverlay.end() );
        BOOST_CHECK_EQUAL( unique.size(), withOverlay.size() );
 
        // The overlay registers two items: the world-space tint overlay and the screen-constant
        // badge item.
        BOOST_CHECK_EQUAL( withOverlay.size(), baseline.size() + 2 );
    }
 
    // After destruction the view must hold no leftover (dangling) reference to the overlay. The
    // pair query only collects pointers, so this is safe even when the overlay has been freed.
    std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> afterDestruction;
    view.Query( maxBox, afterDestruction );
 
    BOOST_CHECK_EQUAL( afterDestruction.size(), baseline.size() );
}
 
 
BOOST_AUTO_TEST_SUITE_END()
 
 
BOOST_AUTO_TEST_SUITE( ConstraintBadges )
 
 
BOOST_AUTO_TEST_CASE( BadgesFanOutAndSelectionToggles )
{
    constexpr int MM = 1000000;
 
    BOARD       board;
    KIGFX::VIEW view;
 
    PCB_SHAPE* seg = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
    seg->SetStart( VECTOR2I( 0, 0 ) );
    seg->SetEnd( VECTOR2I( 10 * MM, 0 ) );
    board.Add( seg );
 
    // Two constraints whose first member resolves to the same point: their badges must not stack.
    auto* c1 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    c1->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c1 );
 
    auto* c2 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    c2->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c2 );
 
    CONSTRAINT_OVERLAY overlay( &board, &view );
    overlay.Update( DiagnoseBoardConstraints( &board ) );
 
    BOOST_REQUIRE_EQUAL( overlay.Badges().size(), 2 );
 
    // The badges store their (shared) anchor; the fan-out lives in the screen-space layout.
    BOOST_CHECK_EQUAL( overlay.Badges()[0].pos, overlay.Badges()[1].pos );
 
    // LayoutBadges separates same-anchor badges by at least the fan step at any zoom, and the
    // separation scales with world-per-pixel -- the regression against the old fixed 1.5 mm fan.
    for( double worldPerPx : { 200.0, 8000.0 } )
    {
        std::vector<VECTOR2D> layout = CONSTRAINT_OVERLAY::LayoutBadges( overlay.Badges(), worldPerPx );
 
        BOOST_REQUIRE_EQUAL( layout.size(), 2 );
        double dist = ( layout[0] - layout[1] ).EuclideanNorm();
        BOOST_TEST( dist >= 18.0 * worldPerPx - 1.0 );
    }
 
    // Selection state changes only on a real change.
    BOOST_TEST( overlay.SetSelected( c1->m_Uuid ) );
    BOOST_TEST( !overlay.SetSelected( c1->m_Uuid ) );
    BOOST_CHECK( overlay.GetSelected() == c1->m_Uuid );
    BOOST_TEST( overlay.SetSelected( niluuid ) );
}
 
 
// Badges on DIFFERENT anchors that project within a glyph of each other at far zoom-out are still
// pushed apart by the layout (the cross-anchor de-overlap the old world-space fan also did).
BOOST_AUTO_TEST_CASE( LayoutDeOverlapsNearbyAnchors )
{
    constexpr int MM = 1000000;
 
    BOARD       board;
    KIGFX::VIEW view;
 
    PCB_SHAPE* seg = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
    seg->SetStart( VECTOR2I( 0, 0 ) );
    seg->SetEnd( VECTOR2I( MM / 10, 0 ) );   // endpoints only 0.1 mm apart
    board.Add( seg );
 
    auto* c1 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    c1->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c1 );
 
    auto* c2 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    c2->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::END );
    board.Add( c2 );
 
    CONSTRAINT_OVERLAY overlay( &board, &view );
    overlay.Update( DiagnoseBoardConstraints( &board ) );
    BOOST_REQUIRE_EQUAL( overlay.Badges().size(), 2 );
 
    const double          worldPerPx = 8000.0;
    std::vector<VECTOR2D> layout = CONSTRAINT_OVERLAY::LayoutBadges( overlay.Badges(), worldPerPx );
 
    BOOST_TEST( ( layout[0] - layout[1] ).EuclideanNorm() >= 18.0 * worldPerPx - 1.0 );
}
 
 
// The visibility mode and hover filter are orthogonal: ALWAYS shows every badge, HOVER with nothing
// hovered shows none, HOVER with a shape shows only its constraints, and a panel isolation wins.
BOOST_AUTO_TEST_CASE( VisibilityModeAndHoverFilter )
{
    constexpr int MM = 1000000;
 
    BOARD       board;
    KIGFX::VIEW view;
 
    PCB_SHAPE* seg1 = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
    seg1->SetStart( VECTOR2I( 0, 0 ) );
    seg1->SetEnd( VECTOR2I( 10 * MM, 0 ) );
    board.Add( seg1 );
 
    PCB_SHAPE* seg2 = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
    seg2->SetStart( VECTOR2I( 0, 10 * MM ) );
    seg2->SetEnd( VECTOR2I( 10 * MM, 10 * MM ) );
    board.Add( seg2 );
 
    auto* c1 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    c1->AddMember( seg1->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c1 );
 
    auto* c2 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    c2->AddMember( seg2->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c2 );
 
    BOARD_CONSTRAINT_DIAGNOSTICS diag = DiagnoseBoardConstraints( &board );
    CONSTRAINT_OVERLAY           overlay( &board, &view );
 
    overlay.SetVisibilityMode( OVERLAY_MODE::ALWAYS );
    overlay.Update( diag );
    BOOST_CHECK_EQUAL( overlay.Badges().size(), 2 );
 
    overlay.SetVisibilityMode( OVERLAY_MODE::HOVER );
    overlay.Update( diag );
    BOOST_CHECK_EQUAL( overlay.Badges().size(), 0 );   // nothing hovered -> hidden
 
    overlay.SetHoverShape( seg1->m_Uuid );
    overlay.Update( diag );
    BOOST_REQUIRE_EQUAL( overlay.Badges().size(), 1 );
    BOOST_CHECK( overlay.Badges()[0].constraint == c1->m_Uuid );
 
    overlay.SetIsolated( c2->m_Uuid );   // panel focus wins over hover
    overlay.Update( diag );
    BOOST_REQUIRE_EQUAL( overlay.Badges().size(), 1 );
    BOOST_CHECK( overlay.Badges()[0].constraint == c2->m_Uuid );
}
 
 
BOOST_AUTO_TEST_CASE( NearestConstrainedShapeUsesCandidatesOnly )
{
    constexpr int MM = 1000000;
 
    BOARD      board;
    PCB_SHAPE* seg = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
    seg->SetStart( VECTOR2I( 0, 0 ) );
    seg->SetEnd( VECTOR2I( 10 * MM, 0 ) );
    board.Add( seg );
 
    std::vector<KIID> candidates = { seg->m_Uuid };
 
    std::optional<KIID> hit = NearestConstrainedShape( &board, candidates, VECTOR2I( 5 * MM, 1000 ), 5000 );
    BOOST_REQUIRE( hit.has_value() );
    BOOST_CHECK( *hit == seg->m_Uuid );
 
    BOOST_CHECK( !NearestConstrainedShape( &board, candidates, VECTOR2I( 5 * MM, 5 * MM ), 5000 ).has_value() );
    BOOST_CHECK( !NearestConstrainedShape( &board, {}, VECTOR2I( 0, 0 ), 5000 ).has_value() );
 
    board.Remove( seg );
    delete seg;
 
    BOOST_CHECK( !NearestConstrainedShape( &board, candidates, VECTOR2I( 5 * MM, 1000 ), 5000 ).has_value() );
}
 
 
BOOST_AUTO_TEST_CASE( ConstrainedShapeIdsDropsMissingMembers )
{
    SETTINGS_MANAGER       settingsManager;
    std::unique_ptr<BOARD> board;
    KI_TEST::LoadBoard( settingsManager, wxS( "api_kitchen_sink" ), board );
 
    // The file's footprint constraints name shapes the footprint no longer has
    auto hasConstraints = []( const FOOTPRINT* aFootprint ) { return !aFootprint->Constraints().empty(); };
    auto fpIt = std::ranges::find_if( board->Footprints(), hasConstraints );
    BOOST_REQUIRE( fpIt != board->Footprints().end() );
 
    FOOTPRINT*      footprint = *fpIt;
    PCB_CONSTRAINT* dangling = footprint->Constraints().front();
    BOOST_REQUIRE( !dangling->GetMembers().empty() );
    BOOST_REQUIRE( !board->ResolveItem( dangling->GetMembers().front().m_item, true ) );
 
    auto shapeIt = std::ranges::find_if( footprint->GraphicalItems(),
                                         []( BOARD_ITEM* aItem ) { return aItem->Type() == PCB_SHAPE_T; } );
    BOOST_REQUIRE( shapeIt != footprint->GraphicalItems().end() );
 
    PCB_CONSTRAINT* live = static_cast<PCB_CONSTRAINT*>( dangling->Clone() );
    live->ResetUuid();
    live->RemapKIIDs( { { dangling->GetMembers().front().m_item, ( *shapeIt )->m_Uuid } } );
    footprint->Add( live );
 
    std::vector<KIID> ids = ConstrainedShapeIds( board.get() );
    BOOST_REQUIRE_EQUAL( ids.size(), 1 );
    BOOST_CHECK( ids.front() == ( *shapeIt )->m_Uuid );
}
 
 
BOOST_AUTO_TEST_SUITE_END()