test_label_bounding_box.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 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 <sch_label.h>
#include <sch_text.h>
#include <font/font.h>
#include <font/outline_font.h>
#include <font/stroke_font.h>
#include <settings/settings_manager.h>
 

struct LABEL_BBOX_FIXTURE
{
    LABEL_BBOX_FIXTURE()
    {
    }
 
    KIFONT::FONT* GetFirstExistingOutlineFont()
    {
        const std::vector<wxString> fontNames = {
            wxS( "Arial" ),
            wxS( "Segoe UI" ),
            wxS( "Tahoma" ),
            wxS( "Verdana" ),
            wxS( "DejaVu Sans" ),
            wxS( "Liberation Sans" ),
            wxS( "FreeSans" ),
            wxS( "Ubuntu" ),
            wxS( "Helvetica" ),
            wxS( "Helvetica Neue" )
        };
 
        for( const wxString& name : fontNames )
        {
            KIFONT::FONT* font = KIFONT::FONT::GetFont( name, false, false );
 
            if( font && font->IsOutline() )
                return font;
        }
 
        return nullptr;
    }

    void CheckTextBoundingBoxWidth( const EDA_TEXT& aText, const wxString& aTestName,
                                     double aMaxWidthMultiplier = 1.3 )
    {
        KIFONT::FONT* font = aText.GetDrawFont( nullptr );
        BOOST_REQUIRE_MESSAGE( font, aTestName + ": Font should not be null" );
 
        VECTOR2I textSize = aText.GetTextSize();
        int      thickness = aText.GetEffectiveTextPenWidth();
        wxString text = aText.GetShownText( true );
 
        // Get the text width from the font using empty metrics (defaults)
        KIFONT::METRICS metrics;
        VECTOR2I extents = font->StringBoundaryLimits( text, textSize, thickness,
                                                        aText.IsBold(), aText.IsItalic(),
                                                        metrics );
 
        // Get the actual bounding box
        BOX2I bbox = aText.GetTextBox( nullptr );
 
        // The bounding box width should be close to the text extents width
        // Allow some margin for font metrics, pen width, etc.
        int expectedMaxWidth = extents.x * aMaxWidthMultiplier;
 
        BOOST_TEST_MESSAGE( aTestName + ": Font: " + font->GetName() );
        BOOST_TEST_MESSAGE( "  Text: '" + text + "'" );
        BOOST_TEST_MESSAGE( "  Text extents width: " + std::to_string( extents.x ) );
        BOOST_TEST_MESSAGE( "  BBox width: " + std::to_string( bbox.GetWidth() ) );
        BOOST_TEST_MESSAGE( "  Expected max width: " + std::to_string( expectedMaxWidth ) );
 
        // Check that bbox is not excessively wide (like double the text width)
        BOOST_CHECK_MESSAGE( bbox.GetWidth() <= expectedMaxWidth,
                             aTestName + ": Bounding box width (" + std::to_string( bbox.GetWidth() )
                             + ") exceeds expected max (" + std::to_string( expectedMaxWidth )
                             + "). Text may have been measured twice." );
 
        // Also check that the bbox is not too small (sanity check)
        int expectedMinWidth = extents.x * 0.7;
        BOOST_CHECK_MESSAGE( bbox.GetWidth() >= expectedMinWidth,
                             aTestName + ": Bounding box width (" + std::to_string( bbox.GetWidth() )
                             + ") is smaller than expected min (" + std::to_string( expectedMinWidth ) + ")" );
    }

    void CheckLabelBodyBoundingBox( SCH_LABEL_BASE& aLabel, const wxString& aTestName )
    {
        BOX2I bodyBBox = aLabel.GetBodyBoundingBox( nullptr );
        BOX2I textBBox = aLabel.GetTextBox( nullptr );
 
        BOOST_TEST_MESSAGE( aTestName + ": Label body bbox width: " + std::to_string( bodyBBox.GetWidth() ) );
        BOOST_TEST_MESSAGE( "  Label text bbox width: " + std::to_string( textBBox.GetWidth() ) );
 
        // Body bbox should be at least as wide as text bbox (may include margins)
        BOOST_CHECK_MESSAGE( bodyBBox.GetWidth() >= textBBox.GetWidth(),
                             aTestName + ": Body bbox width (" + std::to_string( bodyBBox.GetWidth() )
                             + ") should be >= text bbox width (" + std::to_string( textBBox.GetWidth() ) + ")" );
 
        // Body bbox should not be excessively larger than text bbox
        // Allow up to 3x for labels with shapes (global labels, etc.)
        int maxBodyWidth = textBBox.GetWidth() * 3;
        BOOST_CHECK_MESSAGE( bodyBBox.GetWidth() <= maxBodyWidth,
                             aTestName + ": Body bbox width (" + std::to_string( bodyBBox.GetWidth() )
                             + ") is excessively large compared to text bbox width ("
                             + std::to_string( textBBox.GetWidth() ) + ")" );
    }
};
 
 
BOOST_FIXTURE_TEST_SUITE( LabelBoundingBox, LABEL_BBOX_FIXTURE )
 
 

BOOST_AUTO_TEST_CASE( TextBoundingBoxStrokeFont )
{
    SCH_TEXT text( VECTOR2I( 0, 0 ), wxS( "TEST_TEXT" ) );
    text.SetTextSize( VECTOR2I( 1000, 1000 ) );
 
    // Use default KiCad font (stroke font)
    text.SetFont( nullptr );
 
    CheckTextBoundingBoxWidth( text, "SCH_TEXT with stroke font" );
}
 

BOOST_AUTO_TEST_CASE( TextBoundingBoxOutlineFont )
{
    SCH_TEXT text( VECTOR2I( 0, 0 ), wxS( "TEST_TEXT" ) );
    text.SetTextSize( VECTOR2I( 1000, 1000 ) );
 
    // Try to load an outline font - use a common system font
    // If not available, the test will skip
    KIFONT::FONT* font = GetFirstExistingOutlineFont();
 
    if( !font )
    {
        BOOST_TEST_MESSAGE( "Outline font not available, skipping test" );
        return;
    }
 
    text.SetFont( font );
 
    CheckTextBoundingBoxWidth( text, "SCH_TEXT with outline font (" + font->GetName() + ")" );
}
 

BOOST_AUTO_TEST_CASE( TextBoundingBoxVariousStrings )
{
    std::vector<wxString> testStrings = {
        wxS( "A" ),
        wxS( "ABC" ),
        wxS( "TEST" ),
        wxS( "Hello World" ),
        wxS( "1234567890" ),
        wxS( "WWWWW" ),  // Wide characters
        wxS( "iiiii" ),  // Narrow characters
    };
 
    // Test with stroke font
    for( const wxString& str : testStrings )
    {
        SCH_TEXT text( VECTOR2I( 0, 0 ), str );
        text.SetTextSize( VECTOR2I( 1000, 1000 ) );
        text.SetFont( nullptr ); // KiCad stroke font
 
        CheckTextBoundingBoxWidth( text, "Stroke font: '" + str + "'" );
    }
 
    // Test with outline font if available
    KIFONT::FONT* font = GetFirstExistingOutlineFont();
 
    if( font )
    {
        for( const wxString& str : testStrings )
        {
            SCH_TEXT text( VECTOR2I( 0, 0 ), str );
            text.SetTextSize( VECTOR2I( 1000, 1000 ) );
            text.SetFont( font );
 
            CheckTextBoundingBoxWidth( text, "Outline font: '" + str + "'" );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( LabelBodyBoundingBoxStrokeFont )
{
    SCH_LABEL label( VECTOR2I( 0, 0 ), wxS( "TEST_LABEL" ) );
    label.SetTextSize( VECTOR2I( 1000, 1000 ) );
    label.SetFont( nullptr ); // KiCad stroke font
 
    CheckTextBoundingBoxWidth( label, "SCH_LABEL text with stroke font" );
    CheckLabelBodyBoundingBox( label, "SCH_LABEL body with stroke font" );
}
 

BOOST_AUTO_TEST_CASE( LabelBodyBoundingBoxOutlineFont )
{
    KIFONT::FONT* font = GetFirstExistingOutlineFont();
 
    if( !font )
    {
        BOOST_TEST_MESSAGE( "Outline font not available, skipping test" );
        return;
    }
 
    SCH_LABEL label( VECTOR2I( 0, 0 ), wxS( "TEST_LABEL" ) );
    label.SetTextSize( VECTOR2I( 1000, 1000 ) );
    label.SetFont( font );
 
    CheckTextBoundingBoxWidth( label, "SCH_LABEL text with outline font" );
    CheckLabelBodyBoundingBox( label, "SCH_LABEL body with outline font" );
}
 

BOOST_AUTO_TEST_CASE( GlobalLabelBodyBoundingBoxStrokeFont )
{
    SCH_GLOBALLABEL label( VECTOR2I( 0, 0 ), wxS( "GLOBAL_TEST" ) );
    label.SetTextSize( VECTOR2I( 1000, 1000 ) );
    label.SetFont( nullptr ); // KiCad stroke font
 
    CheckTextBoundingBoxWidth( label, "SCH_GLOBALLABEL text with stroke font" );
    CheckLabelBodyBoundingBox( label, "SCH_GLOBALLABEL body with stroke font" );
}
 

BOOST_AUTO_TEST_CASE( GlobalLabelBodyBoundingBoxOutlineFont )
{
    KIFONT::FONT* font = GetFirstExistingOutlineFont();
 
    if( !font )
    {
        BOOST_TEST_MESSAGE( "Outline font not available, skipping test" );
        return;
    }
 
    SCH_GLOBALLABEL label( VECTOR2I( 0, 0 ), wxS( "GLOBAL_TEST" ) );
    label.SetTextSize( VECTOR2I( 1000, 1000 ) );
    label.SetFont( font );
 
    CheckTextBoundingBoxWidth( label, "SCH_GLOBALLABEL text with outline font" );
    CheckLabelBodyBoundingBox( label, "SCH_GLOBALLABEL body with outline font" );
}
 

BOOST_AUTO_TEST_CASE( HierLabelBodyBoundingBoxStrokeFont )
{
    SCH_HIERLABEL label( VECTOR2I( 0, 0 ), wxS( "HIER_TEST" ) );
    label.SetTextSize( VECTOR2I( 1000, 1000 ) );
    label.SetFont( nullptr ); // KiCad stroke font
 
    CheckTextBoundingBoxWidth( label, "SCH_HIERLABEL text with stroke font" );
    CheckLabelBodyBoundingBox( label, "SCH_HIERLABEL body with stroke font" );
}
 

BOOST_AUTO_TEST_CASE( HierLabelBodyBoundingBoxOutlineFont )
{
    KIFONT::FONT* font = GetFirstExistingOutlineFont();
 
    if( !font )
    {
        BOOST_TEST_MESSAGE( "Outline font not available, skipping test" );
        return;
    }
 
    SCH_HIERLABEL label( VECTOR2I( 0, 0 ), wxS( "HIER_TEST" ) );
    label.SetTextSize( VECTOR2I( 1000, 1000 ) );
    label.SetFont( font );
 
    CheckTextBoundingBoxWidth( label, "SCH_HIERLABEL text with outline font" );
    CheckLabelBodyBoundingBox( label, "SCH_HIERLABEL body with outline font" );
}
 

BOOST_AUTO_TEST_CASE( TextOffsetStrokeFontIsZero )
{
    SCH_TEXT text( VECTOR2I( 0, 0 ), wxS( "TEST_TEXT" ) );
    text.SetTextSize( VECTOR2I( 1000, 1000 ) );
    text.SetFont( nullptr ); // KiCad stroke font
 
    VECTOR2I offset = text.GetOffsetToMatchSCH_FIELD( nullptr );
 
    BOOST_CHECK_EQUAL( offset.x, 0 );
    BOOST_CHECK_EQUAL( offset.y, 0 );
}
 

BOOST_AUTO_TEST_CASE( TextOffsetOutlineFontIsNonZero )
{
    KIFONT::FONT* font = GetFirstExistingOutlineFont();
 
    if( !font )
    {
        BOOST_TEST_MESSAGE( "Outline font not available, skipping test" );
        return;
    }
 
    SCH_TEXT text( VECTOR2I( 0, 0 ), wxS( "Line 1\nLine 2\nLine 3" ) );
    text.SetTextSize( VECTOR2I( 1000, 1000 ) );
    text.SetFont( font );
    text.SetMultilineAllowed( true );
 
    VECTOR2I offset = text.GetOffsetToMatchSCH_FIELD( nullptr );
 
    // For outline fonts, the offset must shift the bounding box upward (negative Y) to
    // match the actual rendered position.
    BOOST_CHECK_MESSAGE( offset.y < 0,
                         "Outline font offset Y should be negative (upward shift), got: "
                         + std::to_string( offset.y ) );
 
    // The unshifted bounding box should start below where the text actually renders.
    // After applying the offset, the box top should move up.
    BOX2I rawBBox = text.GetBoundingBox();
    BOX2I shiftedBBox = rawBBox;
    shiftedBBox.Offset( offset );
 
    BOOST_CHECK_MESSAGE( shiftedBBox.GetTop() < rawBBox.GetTop(),
                         "Shifted bounding box top should be above raw bounding box top" );
}
 

BOOST_AUTO_TEST_CASE( BoundingBoxRefreshedAfterFontResolve )
{
    KIFONT::FONT* outlineFont = GetFirstExistingOutlineFont();
 
    if( !outlineFont )
    {
        BOOST_TEST_MESSAGE( "Outline font not available, skipping test" );
        return;
    }
 
    const wxString fontName = outlineFont->GetName();
    const wxString body = wxS( "Line 1\nLine 2\nLine 3" );
 
    // Steady-state reference with the font assigned directly.
    SCH_TEXT reference( VECTOR2I( 0, 0 ), body );
    reference.SetTextSize( VECTOR2I( 1000, 1000 ) );
    reference.SetMultilineAllowed( true );
    reference.SetFont( outlineFont );
 
    BOX2I expected = reference.GetBoundingBox();
 
    // Same text, but the font arrives via deferred resolution instead of SetFont().
    SCH_TEXT deferred( VECTOR2I( 0, 0 ), body );
    deferred.SetTextSize( VECTOR2I( 1000, 1000 ) );
    deferred.SetMultilineAllowed( true );
    deferred.SetUnresolvedFontName( fontName );
 
    // Measure (and cache) the box while the name is still resolving to the stroke fallback.
    BOX2I fallbackBox = deferred.GetBoundingBox();
 
    BOOST_REQUIRE( deferred.ResolveFont( nullptr ) );
 
    BOX2I resolved = deferred.GetBoundingBox();
 
    BOOST_CHECK_MESSAGE( resolved == expected,
                         "Bounding box after ResolveFont() must match the outline-font box; the "
                         "stale fallback-font box ("
                         + std::to_string( fallbackBox.GetHeight() ) + " tall) was not invalidated" );
}
 
 
BOOST_AUTO_TEST_SUITE_END()