kicad-source/pcbnew/teardrop/teardrop.cpp

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2021 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2023 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
 */


#include <confirm.h>

#include <board_design_settings.h>
#include <pcb_track.h>
#include <pad.h>
#include <zone_filler.h>
#include <board_commit.h>

#include "teardrop.h"
#include <geometry/convex_hull.h>
#include <geometry/shape_line_chain.h>
#include <convert_basic_shapes_to_polygon.h>
#include <bezier_curves.h>

#include <wx/log.h>

// The first priority level of a teardrop area (arbitrary value)
#define MAGIC_TEARDROP_ZONE_ID 30000


TEARDROP_MANAGER::TEARDROP_MANAGER( BOARD* aBoard, PCB_EDIT_FRAME* aFrame )
{
    m_board = aBoard;
    m_prmsList = m_board->GetDesignSettings().GetTeadropParamsList();
    m_tolerance = 0;
}


// Build a zone teardrop
static ZONE_SETTINGS s_default_settings;      // Use zone default settings for teardrop

ZONE* TEARDROP_MANAGER::createTeardrop( TEARDROP_VARIANT aTeardropVariant,
                                        std::vector<VECTOR2I>& aPoints, PCB_TRACK* aTrack) const
{
    ZONE* teardrop = new ZONE( m_board );

    // teardrop settings are the last zone settings used by a zone dialog.
    // override them by default.
    s_default_settings.ExportSetting( *teardrop, false );

    // Add zone properties (priority will be fixed later)
    teardrop->SetTeardropAreaType( aTeardropVariant == TD_TYPE_PADVIA ?
                                    TEARDROP_TYPE::TD_VIAPAD :
                                    TEARDROP_TYPE::TD_TRACKEND );
    teardrop->SetLayer( aTrack->GetLayer() );
    teardrop->SetNetCode( aTrack->GetNetCode() );
    teardrop->SetLocalClearance( 0 );
    teardrop->SetMinThickness( pcbIUScale.mmToIU( 0.0254 ) );  // The minimum zone thickness
    teardrop->SetPadConnection( ZONE_CONNECTION::FULL );
    teardrop->SetIsFilled( false );
    teardrop->SetZoneName( aTeardropVariant == TD_TYPE_PADVIA ?
                                MAGIC_TEARDROP_PADVIA_NAME :
                                MAGIC_TEARDROP_TRACK_NAME );
    teardrop->SetIslandRemovalMode( ISLAND_REMOVAL_MODE::NEVER );
    SHAPE_POLY_SET* outline = teardrop->Outline();
    outline->NewOutline();

    for( VECTOR2I pt: aPoints )
        outline->Append(pt.x, pt.y);

    // Used in priority calculations:
    teardrop->CalculateFilledArea();

    return teardrop;
}


int TEARDROP_MANAGER::SetTeardrops( BOARD_COMMIT* aCommitter, bool aFollowTracks )
{
    // Init parameters:
    m_tolerance = pcbIUScale.mmToIU( 0.01 );

    int count = 0;      // Number of created teardrop

    // Old teardrops must be removed, to ensure a clean teardrop rebuild
    int removed_cnt = RemoveTeardrops( aCommitter, false );

    // get vias, PAD_ATTRIB_PTH and others if aIncludeNotDrilled == true
    // (custom pads are not collected)
    std::vector< VIAPAD > viapad_list;

    if( m_prmsList->m_TargetViasPads )
        collectVias( viapad_list );

    collectPadsCandidate( viapad_list, m_prmsList->m_TargetViasPads,
                          m_prmsList->m_UseRoundShapesOnly, m_prmsList->m_TargetPadsWithNoHole );

    TRACK_BUFFER trackLookupList;

    if( aFollowTracks )
    {
        // Build the track list (only straight lines)
        for( PCB_TRACK* track: m_board->Tracks() )
        {
            if( track->Type() == PCB_TRACE_T || track->Type() == PCB_ARC_T)
            {
                int netcode = track->GetNetCode();
                int layer = track->GetLayer();
                trackLookupList.AddTrack( track, layer, netcode );
            }
        }
    }


    std::vector< ZONE*> teardrops;
    collectTeardrops( teardrops );

    for( PCB_TRACK* track : m_board->Tracks() )
    {
        if( ! (track->Type() == PCB_TRACE_T || track->Type() == PCB_ARC_T ) )
            continue;

        // Search for a padvia connected to track, with one end inside and one end outside
        // if both track ends are inside or outside, one cannot build a teadrop
        for( VIAPAD& viapad: viapad_list )
        {
            // Pad and track must be on the same layer
            if( !viapad.IsOnLayer( track->GetLayer() ) )
                continue;

            bool start_in_pad = viapad.m_Parent->HitTest( track->GetStart() );
            bool end_in_pad = viapad.m_Parent->HitTest( track->GetEnd() );

            if( end_in_pad == start_in_pad )
                // the track is inside or outside the via pad. Cannot create a teardrop
                continue;

            // A pointer to one of available m_Parameters items
            TEARDROP_PARAMETERS* currParams;

            if( viapad.m_IsRound )
                currParams = m_prmsList->GetParameters( TARGET_ROUND );
            else
                currParams = m_prmsList->GetParameters( TARGET_RECT );

            // Ensure a teardrop shape can be built:
            // The track width must be < teardrop height
            if( track->GetWidth() >= currParams->m_TdMaxHeight
                || track->GetWidth() >= viapad.m_Width * currParams->m_HeightRatio )
                continue;

            // Ensure also it is not filtered by a too high track->GetWidth()/viapad.m_Width ratio
            if( track->GetWidth() >= viapad.m_Width * currParams->m_WidthtoSizeFilterRatio )
                continue;

            // Skip case where pad/via and the track is within a copper zone with the same net
            // (and the pad can be connected by the zone thermal relief )
            if( !m_prmsList->m_TdOnPadsInZones && isViaAndTrackInSameZone( viapad, track ) )
                continue;

            std::vector<VECTOR2I> points;
            bool success = computeTeardropPolygonPoints( currParams, points, track, viapad,
                                                         aFollowTracks, trackLookupList );

            if( success )
            {
                ZONE* new_teardrop = createTeardrop( TD_TYPE_PADVIA, points, track );
                m_board->Add( new_teardrop, ADD_MODE::BULK_INSERT );
                m_createdTdList.push_back( new_teardrop );

                if( aCommitter )
                    aCommitter->Added( new_teardrop );

                count += 1;
            }
        }
    }

    int track2trackCount = 0;

    if( m_prmsList->m_TargetTrack2Track )
        track2trackCount = addTeardropsOnTracks( aCommitter );

    // Now set priority of teardrops now all teardrops are added
    setTeardropPriorities();

    // Fill teardrop shapes. This is a rough calculation, just to show a filled
    // shape on screen, but most of time this is a good shape.
    // Exact shapes can be calculated only on a full zone refill, **much more** time consuming
    if( m_createdTdList.size() )
    {
        int epsilon = pcbIUScale.mmToIU( 0.001 );

        for( ZONE* zone: m_createdTdList )
        {
            int half_min_width = zone->GetMinThickness() / 2;
            int numSegs = GetArcToSegmentCount( half_min_width, pcbIUScale.mmToIU( 0.005 ), FULL_CIRCLE );
            SHAPE_POLY_SET filledPolys = *zone->Outline();

            filledPolys.Deflate( half_min_width - epsilon, numSegs );

            // Re-inflate after pruning of areas that don't meet minimum-width criteria
            if( half_min_width - epsilon > epsilon )
                filledPolys.Inflate( half_min_width - epsilon, numSegs );

            zone->SetFilledPolysList( zone->GetFirstLayer(), filledPolys );
        }
    }

    if( count || removed_cnt || track2trackCount )
    {
        if( aCommitter )
            aCommitter->Push( _( "Add teardrops" ) );

        // Note:
        // Refill zones can be made only with clean data, especially connectivity data,
        // therefore only after changes are pushed to avoid crashes in some cases
    }

    return count + track2trackCount;
}


void TEARDROP_MANAGER::setTeardropPriorities()
{
    // Note: a teardrop area is on only one layer, so using GetFirstLayer() is OK
    // to know the zone layer of a teardrop

    int priority_base = MAGIC_TEARDROP_ZONE_ID;

    // The sort function to sort by increasing copper layers. Group by layers.
    // For same layers sort by decreasing areas
    struct
    {
        bool operator()(ZONE* a, ZONE* b) const
            {
                if( a->GetFirstLayer() == b->GetFirstLayer() )
                    return a->GetOutlineArea() > b->GetOutlineArea();

                return a->GetFirstLayer() < b->GetFirstLayer();
            }
    } compareLess;

    for( ZONE* td: m_createdTdList )
        td->CalculateOutlineArea();

    std::sort( m_createdTdList.begin(), m_createdTdList.end(), compareLess );

    int curr_layer = -1;

    for( ZONE* td: m_createdTdList )
    {
        if( td->GetFirstLayer() != curr_layer )
        {
            curr_layer = td->GetFirstLayer();
            priority_base = MAGIC_TEARDROP_ZONE_ID;
        }

        td->SetAssignedPriority( priority_base++ );
    }
}


int TEARDROP_MANAGER::addTeardropsOnTracks( BOARD_COMMIT* aCommitter )
{
    TRACK_BUFFER trackLookupList;
    int count = 0;

    // Build the track list (only straight lines)
    for( PCB_TRACK* track: m_board->Tracks() )
    {
        if( track->Type() == PCB_TRACE_T || track->Type() == PCB_ARC_T )
        {
            int netcode = track->GetNetCode();
            int layer = track->GetLayer();
            trackLookupList.AddTrack( track, layer, netcode );
        }
    }

    // get vias and pads (custom pads are not collected). We do not create a track to track
    // teardrop inside a pad or via area
    std::vector< VIAPAD > viapad_list;
    collectVias( viapad_list );
    collectPadsCandidate( viapad_list, true, true, true );

    TEARDROP_PARAMETERS* currParams = m_prmsList->GetParameters( TARGET_TRACK );

    // Explore groups (a group is a set of tracks on the same layer and the same net):
    for( auto& grp : trackLookupList.GetBuffer() )
    {
        int layer, netcode;
        TRACK_BUFFER::GetNetcodeAndLayerFromIndex( grp.first, &layer, &netcode );

        std::vector<PCB_TRACK*>* sublist = grp.second;

        if( sublist->size() <= 1 )  // We need at least 2 track segments
            continue;

        // The sort function to sort by increasing track widths
        struct
        {
            bool operator()(PCB_TRACK* a, PCB_TRACK* b) const
                { return a->GetWidth() < b->GetWidth(); }
        } compareLess;

        std::sort( sublist->begin(), sublist->end(), compareLess );
        int min_width = sublist->front()->GetWidth();
        int max_width = sublist->back()->GetWidth();

        // Skip groups having the same track thickness
        if( max_width == min_width )
            continue;

        for( unsigned ii = 0; ii < sublist->size()-1; ii++ )
        {
            PCB_TRACK* track = (*sublist)[ii];
            int track_len = track->GetLength();
            min_width = track->GetWidth();

            // to avoid creating a teardrop between 2 tracks having similar widths
            // give a threshold
            const double th = currParams->m_WidthtoSizeFilterRatio > 0.1 ?
                                    1.0 / currParams->m_WidthtoSizeFilterRatio
                                    : 10.0;
            min_width = min_width * th;

            for( unsigned jj = ii+1; jj < sublist->size(); jj++ )
            {
                // Search candidates with thickness > curr thickness
                PCB_TRACK* candidate = (*sublist)[jj];

                if( min_width >= candidate->GetWidth() )
                    continue;

                // Cannot build a teardrop on a too short track segment.
                // The min len is > candidate radius
                if( track_len <= candidate->GetWidth() /2 )
                    continue;

                // Now test end to end connection:
                EDA_ITEM_FLAGS match_points;    // to return the end point EDA_ITEM_FLAGS:
                                                // 0, STARTPOINT, ENDPOINT

                VECTOR2I roundshape_pos = candidate->GetStart();
                ENDPOINT_T endPointCandidate = ENDPOINT_START;
                match_points = track->IsPointOnEnds( roundshape_pos, m_tolerance );

                if( !match_points )
                {
                    roundshape_pos = candidate->GetEnd();
                    match_points = track->IsPointOnEnds( roundshape_pos, m_tolerance );
                    endPointCandidate = ENDPOINT_END;
                }

                // Ensure a pad or via is not on test_pos point before creating a teardrop
                // at this location
                for( VIAPAD& viapad : viapad_list )
                {
                    if( viapad.IsOnLayer( track->GetLayer() )
                        && viapad.m_Parent->HitTest( roundshape_pos, 0 ) )
                    {
                        match_points = 0;
                        break;
                    }
                }

                if( match_points )
                {
                    VIAPAD viatrack( candidate, endPointCandidate );
                    std::vector<VECTOR2I> points;
                    bool success = computeTeardropPolygonPoints( currParams,
                                                                 points, track, viatrack,
                                                                 false, trackLookupList );

                    if( success )
                    {
                        ZONE* new_teardrop = createTeardrop( TD_TYPE_TRACKEND, points, track );
                        m_board->Add( new_teardrop, ADD_MODE::BULK_INSERT );
                        m_createdTdList.push_back( new_teardrop );

                        if( aCommitter )
                            aCommitter->Added( new_teardrop );

                        count += 1;
                    }
                }
            }
        }
    }

    return count;
}


int TEARDROP_MANAGER::RemoveTeardrops( BOARD_COMMIT* aCommitter, bool aCommitAfterRemove )
{
    int count = 0;
    std::vector< ZONE*> teardrops;

    collectTeardrops( teardrops );

    for( ZONE* teardrop : teardrops )
    {
        m_board->Remove( teardrop, REMOVE_MODE::BULK );

        if( aCommitter )
            aCommitter->Removed( teardrop );

        count += 1;
    }

    if( count )
    {
        if( aCommitter && aCommitAfterRemove )
            aCommitter->Push( _( "Remove teardrops" ), SKIP_CONNECTIVITY );

        m_board->BuildConnectivity();
    }

    return count;
}