drc_test_provider_creepage.cpp

Go to the documentation of this file.

/*
    * Copyright The KiCad Developers.
    * Copyright (C) 2024 Fabien Corona f.corona<at>laposte.net
    *
    * 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 <common.h>
#include <macros.h>
#include <board_design_settings.h>
#include <footprint.h>
#include <pad.h>
#include <pcb_track.h>
#include <pcb_shape.h>
#include <zone.h>
#include <advanced_config.h>
#include <geometry/shape_rect.h>
#include <geometry/seg.h>
#include <geometry/shape_segment.h>
#include <drc/drc_item.h>
#include <drc/drc_rule.h>
#include <drc/drc_test_provider.h>
#include <drc/drc_creepage_utils.h>
#include <drc/drc_creepage_engine.h>
 
#include <geometry/shape_circle.h>
 
 
/*
    Physical creepage tests.
 
    Errors generated:
    - DRCE_CREEPAGE
*/
 
class DRC_TEST_PROVIDER_CREEPAGE : public DRC_TEST_PROVIDER
{
public:
    DRC_TEST_PROVIDER_CREEPAGE() :
            DRC_TEST_PROVIDER()
    {}
 
    virtual ~DRC_TEST_PROVIDER_CREEPAGE() = default;
 
    virtual bool Run() override;
 
    virtual const wxString GetName() const override { return wxT( "creepage" ); };
 
    double GetMaxConstraint();
 
private:
    int testCreepage();
    int testCreepage( CREEPAGE_GRAPH& aGraph, int aNetCodeA, int aNetCodeB, PCB_LAYER_ID aLayer,
                      double aMaxCreepage, bool aHasConditional );

    int  testCreepageV2( const std::vector<int>& aNetcodes, double aMaxCreepage, bool aHasConditional );

    DRC_CONSTRAINT placeholderConstraint( int aNetCodeA, int aNetCodeB, PCB_LAYER_ID aLayer );
    void reportCreepageViolation( const CREEPAGE_RESULT& aResult, const DRC_CONSTRAINT& aConstraint,
                                  PCB_LAYER_ID aLayer );
 
    void CollectBoardEdges( std::vector<BOARD_ITEM*>& aVector,
                            std::vector<std::unique_ptr<PCB_SHAPE>>& aOwned );
    void CollectNetCodes( std::vector<int>& aVector );
 
    std::set<std::pair<const BOARD_ITEM*, const BOARD_ITEM*>> m_reportedPairs;
};
 
 
bool DRC_TEST_PROVIDER_CREEPAGE::Run()
{
    m_board = m_drcEngine->GetBoard();
    m_reportedPairs.clear();
 
    if( !m_drcEngine->HasRulesForConstraintType( CREEPAGE_CONSTRAINT ) )
    {
        REPORT_AUX( wxT( "No creepage constraints found. Tests not run." ) );
        return true;    // continue with other tests
    }
 
    if( !m_drcEngine->IsErrorLimitExceeded( DRCE_CREEPAGE ) )
    {
        if( !reportPhase( _( "Checking creepage..." ) ) )
            return false; // DRC cancelled
 
        testCreepage();
    }
 
    return !m_drcEngine->IsCancelled();
}
 
 
DRC_CONSTRAINT DRC_TEST_PROVIDER_CREEPAGE::placeholderConstraint( int aNetCodeA, int aNetCodeB,
                                                                 PCB_LAYER_ID aLayer )
{
    PCB_TRACK bci1( m_board );
    PCB_TRACK bci2( m_board );
    bci1.SetNetCode( aNetCodeA );
    bci2.SetNetCode( aNetCodeB );
    bci1.SetLayer( aLayer );
    bci2.SetLayer( aLayer );
 
    return m_drcEngine->EvalRules( CREEPAGE_CONSTRAINT, &bci1, &bci2, aLayer );
}
 
 
int DRC_TEST_PROVIDER_CREEPAGE::testCreepage( CREEPAGE_GRAPH& aGraph, int aNetCodeA, int aNetCodeB,
                                              PCB_LAYER_ID aLayer, double aMaxCreepage,
                                              bool aHasConditional )
{
    // Placeholders at the origin never satisfy intersectsArea(), so conditional rules need a
    // worst-case target and a per-path resolve below. Path cost scales with target, hence the split
    DRC_CONSTRAINT netConstraint;
    double         target;
 
    if( aHasConditional )
    {
        target = aMaxCreepage;
    }
    else
    {
        netConstraint = placeholderConstraint( aNetCodeA, aNetCodeB, aLayer );
        target = netConstraint.Value().Min();
    }
 
    aGraph.SetTarget( target );
 
    if( target <= 0 )
        return 0;
 
    // Let's make a quick "clearance test"
    NETINFO_ITEM* netA = m_board->FindNet( aNetCodeA );
    NETINFO_ITEM* netB = m_board->FindNet( aNetCodeB );
 
    if ( !netA || !netB )
        return 0;
 
    if ( netA->GetBoundingBox().Distance( netB->GetBoundingBox() ) > target )
        return 0;
 
    std::shared_ptr<GRAPH_NODE> NetA = aGraph.AddNetElements( aNetCodeA, aLayer, target );
    std::shared_ptr<GRAPH_NODE> NetB = aGraph.AddNetElements( aNetCodeB, aLayer, target );
 
    aGraph.GeneratePaths( target, aLayer );
 
    std::vector<std::shared_ptr<GRAPH_NODE>> temp_nodes;
 
    std::copy_if( aGraph.m_nodes.begin(), aGraph.m_nodes.end(), std::back_inserter( temp_nodes ),
                  []( std::shared_ptr<GRAPH_NODE> aNode )
                  {
                      return !!aNode && aNode->m_parent && !aNode->m_parent->IsConductive()
                             && !aNode->m_connectDirectly && aNode->m_type == GRAPH_NODE::POINT;
                  } );
 
    alg::for_all_pairs( temp_nodes.begin(), temp_nodes.end(),
                        [&]( std::shared_ptr<GRAPH_NODE> aN1, std::shared_ptr<GRAPH_NODE> aN2 )
                        {
                            if( aN1 == aN2 )
                                return;
 
                            if( !aN1 || !aN2 )
                                return;
 
                            if( !( aN1->m_parent ) || !( aN2->m_parent ) )
                                return;
 
                            if( ( aN1->m_parent ) != ( aN2->m_parent ) )
                                return;
 
                            aN1->m_parent->ConnectChildren( aN1, aN2, aGraph );
                        } );
 
    std::vector<std::shared_ptr<GRAPH_CONNECTION>> shortestPath;
    shortestPath.clear();
    double distance = aGraph.Solve( NetA, NetB, shortestPath );
 
    if( shortestPath.empty() || shortestPath.size() < 4 )
        return 1;
 
    std::shared_ptr<GRAPH_CONNECTION> gc1 = shortestPath[1];
    std::shared_ptr<GRAPH_CONNECTION> gc2 = shortestPath[shortestPath.size() - 2];
 
    const BOARD_ITEM* item1 = gc1->n1 && gc1->n1->m_parent ? gc1->n1->m_parent->GetParent() : nullptr;
    const BOARD_ITEM* item2 = gc2->n2 && gc2->n2->m_parent ? gc2->n2->m_parent->GetParent() : nullptr;
 
    DRC_CONSTRAINT constraint;
 
    if( !aHasConditional )
        constraint = netConstraint;
    else if( item1 && item2 )
        constraint = m_drcEngine->EvalRules( CREEPAGE_CONSTRAINT, item1, item2, aLayer );
    else
        constraint = placeholderConstraint( aNetCodeA, aNetCodeB, aLayer );
 
    double creepageValue = constraint.Value().Min();
 
    if( creepageValue <= 0 || distance - creepageValue >= 0 )
        return 1;
 
    std::shared_ptr<DRC_ITEM> drcItem = DRC_ITEM::Create( DRCE_CREEPAGE );
    drcItem->SetErrorDetail( formatMsg( _( "(%s creepage %s; actual %s)" ),
                                        constraint.GetName(),
                                        creepageValue,
                                        distance ) );
    drcItem->SetViolatingRule( constraint.GetParentRule() );
 
    if( item1 && item2 )
    {
        if( m_reportedPairs.insert( std::make_pair( item1, item2 ) ).second )
            drcItem->SetItems( item1, item2 );
        else
            return 1;
    }
 
    VECTOR2I               startPoint = gc1->m_path.a2;
    VECTOR2I               endPoint = gc2->m_path.a2;
    std::vector<PCB_SHAPE> path;
 
    for( const std::shared_ptr<GRAPH_CONNECTION>& gc : shortestPath )
        gc->GetShapes( path );
 
    reportViolation( drcItem, gc1->m_path.a2, aLayer,
                     [&]( PCB_MARKER* aMarker )
                     {
                         aMarker->SetPath( path, startPoint, endPoint );
                     } );
 
    return 1;
}
 
 
double DRC_TEST_PROVIDER_CREEPAGE::GetMaxConstraint()
{
    // Upper bound to size the graph only; the governing rule is resolved per path in testCreepage.
    // Per-pair placeholder eval would miss conditional rules raising the value inside an area
    DRC_CONSTRAINT worst;
 
    if( m_drcEngine->QueryWorstConstraint( CREEPAGE_CONSTRAINT, worst ) )
        return worst.Value().Min();
 
    return 0;
}
 
 
void DRC_TEST_PROVIDER_CREEPAGE::CollectNetCodes( std::vector<int>& aVector )
{
    NETCODES_MAP nets = m_board->GetNetInfo().NetsByNetcode();
 
    for( auto it = nets.begin(); it != nets.end(); it++ )
        aVector.push_back( it->first );
}
 
 
void DRC_TEST_PROVIDER_CREEPAGE::CollectBoardEdges( std::vector<BOARD_ITEM*>& aVector,
                                                    std::vector<std::unique_ptr<PCB_SHAPE>>& aOwned )
{
    if( !m_board )
        return;
 
    BuildCreepageBoardEdges( *m_board, aVector, aOwned, nullptr );
}
 
 
int DRC_TEST_PROVIDER_CREEPAGE::testCreepage()
{
    if( !m_board )
        return -1;
 
    std::vector<int> netcodes;
 
    this->CollectNetCodes( netcodes );
    double maxConstraint = GetMaxConstraint();
 
    if( maxConstraint <= 0 )
        return 0;
 
    // No conditional rule means the per-pair placeholder target is exact and the graph stays tight
    bool hasConditional = m_drcEngine->HasConditionalConstraint( CREEPAGE_CONSTRAINT );
 
    if( ADVANCED_CFG::GetCfg().m_RealtimeCreepage )
        return testCreepageV2( netcodes, maxConstraint, hasConditional );
 
    SHAPE_POLY_SET outline;
 
    // Subtract NPTH holes from the outline polygon so candidate-path midpoint tests
    // reject creepage segments routed through slot interiors. Without subtraction,
    // a midpoint inside an NPTH oval still counts as "inside the board" and the
    // creepage validator accepts straight-through-slot paths (issue #24286).
    bool hasValidOutline = m_board->GetBoardPolygonOutlines( outline, false, nullptr, false, true );
 
    const DRAWINGS drawings = m_board->Drawings();
    CREEPAGE_GRAPH graph( *m_board );
 
    if( ADVANCED_CFG::GetCfg().m_EnableCreepageSlot )
        graph.m_minGrooveWidth = m_board->GetDesignSettings().m_MinGrooveWidth;
    else
        graph.m_minGrooveWidth = 0;
 
    graph.m_boardOutline = hasValidOutline ? &outline : nullptr;
 
    this->CollectBoardEdges( graph.m_boardEdge, graph.m_ownedBoardEdges );
    graph.TransformEdgeToCreepShapes();
    graph.RemoveDuplicatedShapes();
    graph.TransformCreepShapesToNodes( graph.m_shapeCollection );
 
    graph.GeneratePaths( maxConstraint, Edge_Cuts );
 
    int  beNodeSize = graph.m_nodes.size();
    int  beConnectionsSize = graph.m_connections.size();
    bool prevTestChangedGraph = false;
 
    size_t current = 0;
    size_t total = ( netcodes.size() * ( netcodes.size() - 1 ) ) / 2 * m_board->GetCopperLayerCount();
    LSET layers = m_board->GetLayerSet();
 
    alg::for_all_pairs( netcodes.begin(), netcodes.end(),
                        [&]( int aNet1, int aNet2 )
                        {
                            if( aNet1 == aNet2 )
                                return;
 
                            for( auto it = layers.copper_layers_begin(); it != layers.copper_layers_end(); ++it )
                            {
                                PCB_LAYER_ID layer = *it;
 
                                reportProgress( current++, total );
 
                                if( prevTestChangedGraph )
                                    graph.TruncateToPrefix( beNodeSize, beConnectionsSize );
 
                                prevTestChangedGraph = testCreepage( graph, aNet1, aNet2, layer,
                                                                     maxConstraint, hasConditional );
                            }
                        } );
 
    return 1;
}
 
 
void DRC_TEST_PROVIDER_CREEPAGE::reportCreepageViolation( const CREEPAGE_RESULT& aResult,
                                                          const DRC_CONSTRAINT&  aConstraint,
                                                          PCB_LAYER_ID           aLayer )
{
    if( !aResult.m_itemA || !aResult.m_itemB )
        return;
 
    if( !m_reportedPairs.insert( std::make_pair( aResult.m_itemA, aResult.m_itemB ) ).second )
        return;
 
    std::shared_ptr<DRC_ITEM> drcItem = DRC_ITEM::Create( DRCE_CREEPAGE );
    drcItem->SetErrorDetail( formatMsg( _( "(%s creepage %s; actual %s)" ), aConstraint.GetName(),
                                        aConstraint.GetValue().Min(), aResult.m_distance ) );
    drcItem->SetViolatingRule( aConstraint.GetParentRule() );
    drcItem->SetItems( aResult.m_itemA, aResult.m_itemB );
 
    // reportViolation invokes the callback inline, so the marker can reference aResult directly
    reportViolation( drcItem, aResult.m_start, aLayer,
                     [&]( PCB_MARKER* aMarker )
                     {
                         aMarker->SetPath( aResult.m_path, aResult.m_start, aResult.m_end );
                     } );
}
 
 
int DRC_TEST_PROVIDER_CREEPAGE::testCreepageV2( const std::vector<int>& aNetcodes, double aMaxCreepage,
                                                bool aHasConditional )
{
    CREEPAGE_ENGINE engine( *m_board );
 
    if( ADVANCED_CFG::GetCfg().m_EnableCreepageSlot )
        engine.SetMinGrooveWidth( m_board->GetDesignSettings().m_MinGrooveWidth );
 
    LSET   layers = m_board->GetLayerSet();
    size_t current = 0;
    size_t total = ( aNetcodes.size() * ( aNetcodes.size() - 1 ) ) / 2 * m_board->GetCopperLayerCount();
 
    alg::for_all_pairs( aNetcodes.begin(), aNetcodes.end(),
            [&]( int aNet1, int aNet2 )
            {
                if( aNet1 == aNet2 )
                    return;
 
                for( auto it = layers.copper_layers_begin(); it != layers.copper_layers_end(); ++it )
                {
                    PCB_LAYER_ID layer = *it;
 
                    reportProgress( current++, total );
 
                    // Conditional rules solve at worst-case so no path is pruned, then resolve
                    // from the conductors the engine returns; otherwise the placeholder is exact
                    DRC_CONSTRAINT netConstraint;
                    double         target;
 
                    if( aHasConditional )
                    {
                        target = aMaxCreepage;
                    }
                    else
                    {
                        netConstraint = placeholderConstraint( aNet1, aNet2, layer );
                        target = netConstraint.Value().Min();
                    }
 
                    std::optional<CREEPAGE_RESULT> result =
                            engine.SolveNetPairWholeBoard( aNet1, aNet2, layer, target );
 
                    if( !result || !result->m_itemA || !result->m_itemB )
                        continue;
 
                    DRC_CONSTRAINT constraint =
                            aHasConditional
                                    ? m_drcEngine->EvalRules( CREEPAGE_CONSTRAINT, result->m_itemA,
                                                              result->m_itemB, layer )
                                    : netConstraint;
                    double creepageValue = constraint.Value().Min();
 
                    if( creepageValue > 0 && result->m_distance - creepageValue < 0 )
                        reportCreepageViolation( *result, constraint, layer );
                }
            } );
 
    return 1;
}
 
 
namespace detail
{
static DRC_REGISTER_TEST_PROVIDER<DRC_TEST_PROVIDER_CREEPAGE> dummy;
}