DRC_TEST_PROVIDER_COPPER_CLEARANCE Class Reference

Inheritance diagram for DRC_TEST_PROVIDER_COPPER_CLEARANCE:

Public Member Functions
	DRC_TEST_PROVIDER_COPPER_CLEARANCE ()
virtual	~DRC_TEST_PROVIDER_COPPER_CLEARANCE ()
virtual bool	Run () override
	Run this provider against the given PCB with configured options (if any). More...
virtual const wxString	GetName () const override
virtual const wxString	GetDescription () const override
virtual std::set< DRC_CONSTRAINT_T >	GetConstraintTypes () const override
int	GetNumPhases () const override
void	SetDRCEngine (DRC_ENGINE *engine)
virtual bool	IsRuleDriven () const
bool	IsEnabled () const
void	Enable (bool aEnable)

Protected Member Functions
int	forEachGeometryItem (const std::vector< KICAD_T > &aTypes, LSET aLayers, const std::function< bool(BOARD_ITEM *)> &aFunc)
virtual void	reportAux (wxString fmt,...)
virtual void	reportViolation (std::shared_ptr< DRC_ITEM > &item, const wxPoint &aMarkerPos)
virtual bool	reportProgress (int aCount, int aSize, int aDelta)
virtual bool	reportPhase (const wxString &aStageName)
virtual void	reportRuleStatistics ()
virtual void	accountCheck (const DRC_RULE *ruleToTest)
virtual void	accountCheck (const DRC_CONSTRAINT &constraintToTest)
bool	isInvisibleText (const BOARD_ITEM *aItem) const
EDA_UNITS	userUnits () const

Protected Attributes
BOARD *	m_board
int	m_largestClearance
bool	m_boardOutlineValid
DRC_ENGINE *	m_drcEngine
std::unordered_map< const DRC_RULE *, int >	m_stats
bool	m_isRuleDriven = true
bool	m_enabled = true

Static Protected Attributes
static std::vector< KICAD_T >	s_allBasicItems
static std::vector< KICAD_T >	s_allBasicItemsButZones

Private Member Functions
bool	testTrackAgainstItem (PCB_TRACK *track, SHAPE *trackShape, PCB_LAYER_ID layer, BOARD_ITEM *other)
void	testTrackClearances ()
bool	testPadAgainstItem (PAD *pad, SHAPE *padShape, PCB_LAYER_ID layer, BOARD_ITEM *other)
void	testPadClearances ()
void	testZonesToZones ()
void	testItemAgainstZones (BOARD_ITEM *aItem, PCB_LAYER_ID aLayer)

Private Attributes
DRC_RTREE	m_copperTree
int	m_drcEpsilon
std::vector< ZONE * >	m_zones

Detailed Description

Definition at line 56 of file drc_test_provider_copper_clearance.cpp.

Constructor & Destructor Documentation

DRC_TEST_PROVIDER_COPPER_CLEARANCE()

DRC_TEST_PROVIDER_COPPER_CLEARANCE::DRC_TEST_PROVIDER_COPPER_CLEARANCE ( )

inline

Definition at line 59 of file drc_test_provider_copper_clearance.cpp.

 :
 DRC_TEST_PROVIDER_CLEARANCE_BASE(),
 m_drcEpsilon( 0 )
 {
 }

~DRC_TEST_PROVIDER_COPPER_CLEARANCE()

virtual DRC_TEST_PROVIDER_COPPER_CLEARANCE::~DRC_TEST_PROVIDER_COPPER_CLEARANCE ( )

inlinevirtual

Definition at line 65 of file drc_test_provider_copper_clearance.cpp.

 {
 }

Member Function Documentation

accountCheck() [1/2]

void DRC_TEST_PROVIDER::accountCheck ( const DRC_RULE *  ruleToTest )

protectedvirtualinherited

Definition at line 103 of file drc_test_provider.cpp.

{
 auto it = m_stats.find( ruleToTest );

 if( it == m_stats.end() )
 m_stats[ ruleToTest ] = 1;
 else
 m_stats[ ruleToTest ] += 1;
}

References DRC_TEST_PROVIDER::m_stats.

Referenced by DRC_TEST_PROVIDER::accountCheck(), and DRC_TEST_PROVIDER::reportViolation().

accountCheck() [2/2]

void DRC_TEST_PROVIDER::accountCheck ( const DRC_CONSTRAINT &  constraintToTest )

protectedvirtualinherited

Definition at line 114 of file drc_test_provider.cpp.

{
 accountCheck( constraintToTest.GetParentRule() );
}

References DRC_TEST_PROVIDER::accountCheck(), and DRC_CONSTRAINT::GetParentRule().

Enable()

void DRC_TEST_PROVIDER::Enable ( bool  aEnable )

inlineinherited

Definition at line 106 of file drc_test_provider.h.

 {
 m_enabled = aEnable;
 }

References DRC_TEST_PROVIDER::m_enabled.

forEachGeometryItem()

int DRC_TEST_PROVIDER::forEachGeometryItem ( const std::vector< KICAD_T > &  aTypes, LSET  aLayers, const std::function< bool(BOARD_ITEM *)> &  aFunc  )

protectedinherited

Definition at line 139 of file drc_test_provider.cpp.

{
 BOARD *brd = m_drcEngine->GetBoard();
 std::bitset<MAX_STRUCT_TYPE_ID> typeMask;
 int n = 0;

 if( s_allBasicItems.size() == 0 )
 {
 for( int i = 0; i < MAX_STRUCT_TYPE_ID; i++ )
 {
 if( i != PCB_FOOTPRINT_T && i != PCB_GROUP_T )
 {
 s_allBasicItems.push_back( (KICAD_T) i );

 if( i != PCB_ZONE_T && i != PCB_FP_ZONE_T )
 s_allBasicItemsButZones.push_back( (KICAD_T) i );
 }
 }
 }

 if( aTypes.size() == 0 )
 {
 for( int i = 0; i < MAX_STRUCT_TYPE_ID; i++ )
 typeMask[ i ] = true;
 }
 else
 {
 for( KICAD_T aType : aTypes )
 typeMask[ aType ] = true;
 }

 for( PCB_TRACK* item : brd->Tracks() )
 {
 if( (item->GetLayerSet() & aLayers).any() )
 {
 if( typeMask[ PCB_TRACE_T ] && item->Type() == PCB_TRACE_T )
 {
 aFunc( item );
 n++;
  }
 else if( typeMask[ PCB_VIA_T ] && item->Type() == PCB_VIA_T )
 {
 aFunc( item );
 n++;
 }
 else if( typeMask[ PCB_ARC_T ] && item->Type() == PCB_ARC_T )
 {
 aFunc( item );
 n++;
 }
 }
 }

 for( BOARD_ITEM* item : brd->Drawings() )
 {
 if( (item->GetLayerSet() & aLayers).any() )
 {
 if( typeMask[PCB_DIMENSION_T] && BaseType( item->Type() ) == PCB_DIMENSION_T )
 {
 if( !aFunc( item ) )
 return n;

 n++;
 }
 else if( typeMask[ PCB_SHAPE_T ] && item->Type() == PCB_SHAPE_T )
 {
 if( !aFunc( item ) )
 return n;

 n++;
 }
 else if( typeMask[ PCB_TEXT_T ] && item->Type() == PCB_TEXT_T )
 {
 if( !aFunc( item ) )
 return n;

 n++;
 }
 else if( typeMask[ PCB_TARGET_T ] && item->Type() == PCB_TARGET_T )
 {
 if( !aFunc( item ) )
 return n;

 n++;
 }
 }
 }

 if( typeMask[ PCB_ZONE_T ] )
 {
 for( ZONE* item : brd->Zones() )
 {
 if( ( item->GetLayerSet() & aLayers ).any() )
 {
 if( !aFunc( item ) )
 return n;

 n++;
 }
 }
 }

 for( FOOTPRINT* footprint : brd->Footprints() )
 {
 if( typeMask[ PCB_FP_TEXT_T ] )
 {
 if( ( footprint->Reference().GetLayerSet() & aLayers ).any() )
 {
 if( !aFunc( &footprint->Reference() ) )
 return n;

 n++;
 }

 if( ( footprint->Value().GetLayerSet() & aLayers ).any() )
 {
 if( !aFunc( &footprint->Value() ) )
 return n;

 n++;
 }
 }

 if( typeMask[ PCB_PAD_T ] )
 {
 for( PAD* pad : footprint->Pads() )
 {
 // Careful: if a pad has a hole then it pierces all layers
 if( ( pad->GetDrillSizeX() > 0 && pad->GetDrillSizeY() > 0 )
 || ( pad->GetLayerSet() & aLayers ).any() )
 {
 if( !aFunc( pad ) )
 return n;

 n++;
 }
 }
 }

 for( BOARD_ITEM* dwg : footprint->GraphicalItems() )
 {
 if( (dwg->GetLayerSet() & aLayers).any() )
 {
 if( typeMask[ PCB_FP_TEXT_T ] && dwg->Type() == PCB_FP_TEXT_T )
 {
 if( !aFunc( dwg ) )
 return n;

 n++;
 }
 else if( typeMask[ PCB_FP_SHAPE_T ] && dwg->Type() == PCB_FP_SHAPE_T )
 {
 if( !aFunc( dwg ) )
 return n;

 n++;
 }
 }
 }

 if( typeMask[ PCB_FP_ZONE_T ] )
 {
 for( ZONE* zone : footprint->Zones() )
 {
 if( (zone->GetLayerSet() & aLayers).any() )
 {
 if( !aFunc( zone ) )
 return n;

 n++;
 }
 }
 }

 if( typeMask[ PCB_FOOTPRINT_T ] )
 {
 if( !aFunc( footprint ) )
 return n;

 n++;
 }
 }

 return n;
}

References BaseType(), BOARD::Drawings(), BOARD::Footprints(), DRC_ENGINE::GetBoard(), DRC_TEST_PROVIDER::m_drcEngine, MAX_STRUCT_TYPE_ID, pad, PCB_ARC_T, PCB_DIMENSION_T, PCB_FOOTPRINT_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_GROUP_T, PCB_PAD_T, PCB_SHAPE_T, PCB_TARGET_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_T, DRC_TEST_PROVIDER::s_allBasicItems, DRC_TEST_PROVIDER::s_allBasicItemsButZones, BOARD::Tracks(), and BOARD::Zones().

Referenced by DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), Run(), DRC_TEST_PROVIDER_MATCHED_LENGTH::runInternal(), DRC_TEST_PROVIDER_MISC::testDisabledLayers(), and DRC_TEST_PROVIDER_MISC::testTextVars().

GetConstraintTypes()

std::set< DRC_CONSTRAINT_T > DRC_TEST_PROVIDER_COPPER_CLEARANCE::GetConstraintTypes ( ) const

overridevirtual

Implements DRC_TEST_PROVIDER.

Definition at line 1026 of file drc_test_provider_copper_clearance.cpp.

{
 return { CLEARANCE_CONSTRAINT, HOLE_CLEARANCE_CONSTRAINT };
}

References CLEARANCE_CONSTRAINT, and HOLE_CLEARANCE_CONSTRAINT.

GetDescription()

virtual const wxString DRC_TEST_PROVIDER_COPPER_CLEARANCE::GetDescription ( ) const

inlineoverridevirtual

Reimplemented from DRC_TEST_PROVIDER.

Definition at line 76 of file drc_test_provider_copper_clearance.cpp.

 {
 return wxT( "Tests copper item clearance" );
 }

GetName()

virtual const wxString DRC_TEST_PROVIDER_COPPER_CLEARANCE::GetName ( void  ) const

inlineoverridevirtual

Reimplemented from DRC_TEST_PROVIDER.

Definition at line 71 of file drc_test_provider_copper_clearance.cpp.

 {
 return wxT( "clearance" );
 };

GetNumPhases()

int DRC_TEST_PROVIDER_COPPER_CLEARANCE::GetNumPhases ( ) const

overridevirtual

Implements DRC_TEST_PROVIDER.

Definition at line 1020 of file drc_test_provider_copper_clearance.cpp.

{
 return 4;
}

IsEnabled()

bool DRC_TEST_PROVIDER::IsEnabled ( ) const

inlineinherited

Definition at line 101 of file drc_test_provider.h.

 {
 return m_enabled;
 }

References DRC_TEST_PROVIDER::m_enabled.

isInvisibleText()

bool DRC_TEST_PROVIDER::isInvisibleText ( const BOARD_ITEM *  aItem ) const

protectedinherited

Definition at line 327 of file drc_test_provider.cpp.

{

 if( const FP_TEXT* text = dyn_cast<const FP_TEXT*>( aItem ) )
 {
 if( !text->IsVisible() )
 return true;
 }

 if( const PCB_TEXT* text = dyn_cast<const PCB_TEXT*>( aItem ) )
 {
 if( !text->IsVisible() )
 return true;
 }

 return false;
}

References text.

Referenced by DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), and DRC_TEST_PROVIDER_SILK_CLEARANCE::Run().

IsRuleDriven()

virtual bool DRC_TEST_PROVIDER::IsRuleDriven ( ) const

inlinevirtualinherited

Definition at line 96 of file drc_test_provider.h.

 {
 return m_isRuleDriven;
 }

References DRC_TEST_PROVIDER::m_isRuleDriven.

reportAux()

void DRC_TEST_PROVIDER::reportAux ( wxString  fmt,   ...  )

protectedvirtualinherited

Definition at line 86 of file drc_test_provider.cpp.

{
 va_list vargs;
 va_start( vargs, fmt );
 wxString str;
 str.PrintfV( fmt, vargs );
 va_end( vargs );
 m_drcEngine->ReportAux( str );
}

References DRC_TEST_PROVIDER::m_drcEngine, and DRC_ENGINE::ReportAux().

Referenced by DRC_TEST_PROVIDER::reportPhase(), DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::Run(), DRC_TEST_PROVIDER_LVS::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), Run(), DRC_TEST_PROVIDER_MATCHED_LENGTH::runInternal(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testFootprintCourtyardDefinitions(), testPadClearances(), and testTrackClearances().

reportPhase()

bool DRC_TEST_PROVIDER::reportPhase ( const wxString &  aStageName )

protectedvirtualinherited

Definition at line 79 of file drc_test_provider.cpp.

{
 reportAux( aMessage );
 return m_drcEngine->ReportPhase( aMessage );
}

References DRC_TEST_PROVIDER::m_drcEngine, DRC_TEST_PROVIDER::reportAux(), and DRC_ENGINE::ReportPhase().

Referenced by DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_HOLE_SIZE::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_CONNECTIVITY::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), DRC_TEST_PROVIDER_LVS::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), DRC_TEST_PROVIDER_MISC::Run(), Run(), DRC_TEST_PROVIDER_MATCHED_LENGTH::runInternal(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), and DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testFootprintCourtyardDefinitions().

reportProgress()

bool DRC_TEST_PROVIDER::reportProgress ( int  aCount, int  aSize, int  aDelta  )

protectedvirtualinherited

Definition at line 67 of file drc_test_provider.cpp.

{
 if( ( aCount % aDelta ) == 0 || aCount == aSize - 1 )
 {
 if( !m_drcEngine->ReportProgress( (double) aCount / (double) aSize ) )
 return false;
 }

 return true;
}

References DRC_TEST_PROVIDER::m_drcEngine, and DRC_ENGINE::ReportProgress().

Referenced by DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_CONNECTIVITY::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), Run(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_MISC::testDisabledLayers(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testFootprintCourtyardDefinitions(), testPadClearances(), DRC_TEST_PROVIDER_MISC::testTextVars(), testTrackClearances(), and testZonesToZones().

reportRuleStatistics()

void DRC_TEST_PROVIDER::reportRuleStatistics ( )

protectedvirtualinherited

Definition at line 120 of file drc_test_provider.cpp.

{
 if( !m_isRuleDriven )
 return;

 m_drcEngine->ReportAux( wxT( "Rule hit statistics: " ) );

 for( const std::pair<const DRC_RULE* const, int>& stat : m_stats )
 {
 if( stat.first )
 {
 m_drcEngine->ReportAux( wxString::Format( wxT( " - rule '%s': %d hits " ),
 stat.first->m_Name,
 stat.second ) );
 }
 }
}

References Format(), DRC_TEST_PROVIDER::m_drcEngine, DRC_TEST_PROVIDER::m_isRuleDriven, DRC_TEST_PROVIDER::m_stats, and DRC_ENGINE::ReportAux().

Referenced by DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_HOLE_SIZE::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_CONNECTIVITY::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), DRC_TEST_PROVIDER_LVS::Run(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), Run(), and DRC_TEST_PROVIDER_MATCHED_LENGTH::runInternal().

reportViolation()

void DRC_TEST_PROVIDER::reportViolation ( std::shared_ptr< DRC_ITEM > &  item, const wxPoint &  aMarkerPos  )

protectedvirtualinherited

Definition at line 56 of file drc_test_provider.cpp.

{
 if( item->GetViolatingRule() )
 accountCheck( item->GetViolatingRule() );

 item->SetViolatingTest( this );
 m_drcEngine->ReportViolation( item, aMarkerPos );
}

References DRC_TEST_PROVIDER::accountCheck(), DRC_TEST_PROVIDER::m_drcEngine, and DRC_ENGINE::ReportViolation().

Referenced by DRC_TEST_PROVIDER_MATCHED_LENGTH::checkLengths(), DRC_TEST_PROVIDER_HOLE_SIZE::checkPad(), DRC_TEST_PROVIDER_MATCHED_LENGTH::checkSkews(), DRC_TEST_PROVIDER_HOLE_SIZE::checkVia(), DRC_TEST_PROVIDER_MATCHED_LENGTH::checkViaCounts(), DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_CONNECTIVITY::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::testAgainstEdge(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_MISC::testDisabledLayers(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testFootprintCourtyardDefinitions(), DRC_TEST_PROVIDER_LVS::testFootprints(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::testHoleAgainstHole(), testItemAgainstZones(), DRC_TEST_PROVIDER_MISC::testOutline(), testPadAgainstItem(), DRC_TEST_PROVIDER_MISC::testTextVars(), testTrackAgainstItem(), and testZonesToZones().

Run()

bool DRC_TEST_PROVIDER_COPPER_CLEARANCE::Run ( )

overridevirtual

Run this provider against the given PCB with configured options (if any).

Implements DRC_TEST_PROVIDER.

Definition at line 107 of file drc_test_provider_copper_clearance.cpp.

{
 m_board = m_drcEngine->GetBoard();
 DRC_CONSTRAINT worstConstraint;

 if( m_drcEngine->QueryWorstConstraint( CLEARANCE_CONSTRAINT, worstConstraint ) )
 m_largestClearance = worstConstraint.GetValue().Min();

 if( m_drcEngine->QueryWorstConstraint( HOLE_CLEARANCE_CONSTRAINT, worstConstraint ) )
 m_largestClearance = std::max( m_largestClearance, worstConstraint.GetValue().Min() );

 if( m_largestClearance <= 0 )
 {
 reportAux( "No Clearance constraints found. Tests not run." );
 return true; // continue with other tests
 }

 m_drcEpsilon = m_board->GetDesignSettings().GetDRCEpsilon();

 m_zones.clear();

 for( ZONE* zone : m_board->Zones() )
 {
 if( !zone->GetIsRuleArea() )
 {
 m_zones.push_back( zone );
 m_largestClearance = std::max( m_largestClearance, zone->GetLocalClearance() );
 }
 }

 for( FOOTPRINT* footprint : m_board->Footprints() )
 {
 for( PAD* pad : footprint->Pads() )
 m_largestClearance = std::max( m_largestClearance, pad->GetLocalClearance() );

  for( ZONE* zone : footprint->Zones() )
 {
 if( !zone->GetIsRuleArea() )
 {
 m_zones.push_back( zone );
 m_largestClearance = std::max( m_largestClearance, zone->GetLocalClearance() );
 }
 }
 }

 reportAux( wxT( "Worst clearance : %d nm" ), m_largestClearance );

 // This is the number of tests between 2 calls to the progress bar
 size_t delta = 50;
 size_t count = 0;
 size_t ii = 0;

 m_copperTree.clear();

 auto countItems =
 [&]( BOARD_ITEM* item ) -> bool
 {
 ++count;
 return true;
 };

 auto addToCopperTree =
 [&]( BOARD_ITEM* item ) -> bool
 {
 if( !reportProgress( ii++, count, delta ) )
 return false;

 LSET layers = item->GetLayerSet();

 // Special-case pad holes which pierce all the copper layers
 if( item->Type() == PCB_PAD_T )
 {
 PAD* pad = static_cast<PAD*>( item );

 if( pad->GetDrillSizeX() > 0 && pad->GetDrillSizeY() > 0 )
 layers |= LSET::AllCuMask();
 }

 for( PCB_LAYER_ID layer : layers.Seq() )
 {
 if( IsCopperLayer( layer ) )
 m_copperTree.Insert( item, layer, m_largestClearance );
 }

 return true;
 };

 if( !reportPhase( _( "Gathering copper items..." ) ) )
 return false; // DRC cancelled

 static const std::vector<KICAD_T> itemTypes = {
 PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T, PCB_PAD_T, PCB_SHAPE_T, PCB_FP_SHAPE_T,
 PCB_TEXT_T, PCB_FP_TEXT_T, PCB_DIMENSION_T, PCB_DIM_ALIGNED_T, PCB_DIM_LEADER_T,
 PCB_DIM_CENTER_T, PCB_DIM_ORTHOGONAL_T
 };

 forEachGeometryItem( itemTypes, LSET::AllCuMask(), countItems );
 forEachGeometryItem( itemTypes, LSET::AllCuMask(), addToCopperTree );

 reportAux( wxT( "Testing %d copper items and %d zones..." ), count, m_zones.size() );

 if( !m_drcEngine->IsErrorLimitExceeded( DRCE_CLEARANCE ) )
 {
 if( !reportPhase( _( "Checking track & via clearances..." ) ) )
 return false; // DRC cancelled

 testTrackClearances();
 }
 else if( !m_drcEngine->IsErrorLimitExceeded( DRCE_HOLE_CLEARANCE ) )
 {
 if( !reportPhase( _( "Checking hole clearances..." ) ) )
 return false; // DRC cancelled

 testTrackClearances();
 }

 if( !m_drcEngine->IsErrorLimitExceeded( DRCE_CLEARANCE ) )
 {
 if( !reportPhase( _( "Checking pad clearances..." ) ) )
 return false; // DRC cancelled

 testPadClearances();
 }
 else if( !m_drcEngine->IsErrorLimitExceeded( DRCE_SHORTING_ITEMS )
 || !m_drcEngine->IsErrorLimitExceeded( DRCE_HOLE_CLEARANCE ) )
 {
 if( !reportPhase( _( "Checking pads..." ) ) )
 return false; // DRC cancelled

 testPadClearances();
 }

 if( !m_drcEngine->IsErrorLimitExceeded( DRCE_CLEARANCE ) )
 {
 if( !reportPhase( _( "Checking copper zone clearances..." ) ) )
 return false; // DRC cancelled

 testZonesToZones();
 }
 else if( !m_drcEngine->IsErrorLimitExceeded( DRCE_ZONES_INTERSECT ) )
 {
 if( !reportPhase( _( "Checking zones..." ) ) )
 return false; // DRC cancelled

 testZonesToZones();
 }

 reportRuleStatistics();

 return true;
}

References _, LSET::AllCuMask(), DRC_RTREE::clear(), CLEARANCE_CONSTRAINT, delta, DRCE_CLEARANCE, DRCE_HOLE_CLEARANCE, DRCE_SHORTING_ITEMS, DRCE_ZONES_INTERSECT, BOARD::Footprints(), DRC_TEST_PROVIDER::forEachGeometryItem(), DRC_ENGINE::GetBoard(), BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetDRCEpsilon(), DRC_CONSTRAINT::GetValue(), HOLE_CLEARANCE_CONSTRAINT, DRC_RTREE::Insert(), IsCopperLayer(), DRC_ENGINE::IsErrorLimitExceeded(), DRC_TEST_PROVIDER_CLEARANCE_BASE::m_board, m_copperTree, DRC_TEST_PROVIDER::m_drcEngine, m_drcEpsilon, DRC_TEST_PROVIDER_CLEARANCE_BASE::m_largestClearance, m_zones, MINOPTMAX< T >::Min(), pad, PCB_ARC_T, PCB_DIM_ALIGNED_T, PCB_DIM_CENTER_T, PCB_DIM_LEADER_T, PCB_DIM_ORTHOGONAL_T, PCB_DIMENSION_T, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_PAD_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_TRACE_T, PCB_VIA_T, DRC_ENGINE::QueryWorstConstraint(), DRC_TEST_PROVIDER::reportAux(), DRC_TEST_PROVIDER::reportPhase(), DRC_TEST_PROVIDER::reportProgress(), DRC_TEST_PROVIDER::reportRuleStatistics(), LSET::Seq(), testPadClearances(), testTrackClearances(), testZonesToZones(), and BOARD::Zones().

SetDRCEngine()

void DRC_TEST_PROVIDER::SetDRCEngine ( DRC_ENGINE *  engine )

inlineinherited

Definition at line 78 of file drc_test_provider.h.

 {
 m_drcEngine = engine;
 m_stats.clear();
 }

References DRC_TEST_PROVIDER::m_drcEngine, and DRC_TEST_PROVIDER::m_stats.

testItemAgainstZones()

void DRC_TEST_PROVIDER_COPPER_CLEARANCE::testItemAgainstZones ( BOARD_ITEM *  aItem, PCB_LAYER_ID  aLayer  )

private

Definition at line 382 of file drc_test_provider_copper_clearance.cpp.

{
 for( ZONE* zone : m_zones )
 {
 if( !zone->GetLayerSet().test( aLayer ) )
 continue;

 if( zone->GetNetCode() && aItem->IsConnected() )
 {
 if( zone->GetNetCode() == static_cast<BOARD_CONNECTED_ITEM*>( aItem )->GetNetCode() )
 continue;
 }

 if( aItem->GetBoundingBox().Intersects( zone->GetCachedBoundingBox() ) )
 {
 bool testClearance = !m_drcEngine->IsErrorLimitExceeded( DRCE_CLEARANCE );
 bool testHoles = !m_drcEngine->IsErrorLimitExceeded( DRCE_HOLE_CLEARANCE );

 if( !testClearance && !testHoles )
 return;

 DRC_RTREE* zoneTree = m_board->m_CopperZoneRTrees[ zone ].get();
 EDA_RECT itemBBox = aItem->GetBoundingBox();
 DRC_CONSTRAINT constraint;
 int clearance = -1;
 int actual;
 VECTOR2I pos;

 if( zoneTree && testClearance )
 {
 constraint = m_drcEngine->EvalRules( CLEARANCE_CONSTRAINT, aItem, zone, aLayer );
 clearance = constraint.GetValue().Min();
 }

 if( clearance >= 0 )
 {
 std::shared_ptr<SHAPE> itemShape = aItem->GetEffectiveShape( aLayer );

 if( aItem->Type() == PCB_PAD_T )
 {
 PAD* pad = static_cast<PAD*>( aItem );

 if( !pad->FlashLayer( aLayer ) )
 {
 if( pad->GetDrillSize().x == 0 && pad->GetDrillSize().y == 0 )
 continue;

 const SHAPE_SEGMENT* hole = pad->GetEffectiveHoleShape();
 int size = hole->GetWidth();

 // Note: drill size represents finish size, which means the actual hole
 // size is 2x the plating thickness larger.
 if( pad->GetAttribute() == PAD_ATTRIB::PTH )
 size += 2 * m_board->GetDesignSettings().GetHolePlatingThickness();

 itemShape = std::make_shared<SHAPE_SEGMENT>( hole->GetSeg(), size );
 }
 }

 if( zoneTree && zoneTree->QueryColliding( itemBBox, itemShape.get(), aLayer,
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( aItem, zone );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );
 }
 }

 if( testHoles && ( aItem->Type() == PCB_VIA_T || aItem->Type() == PCB_PAD_T ) )
 {
 std::unique_ptr<SHAPE_SEGMENT> holeShape;

 if( aItem->Type() == PCB_VIA_T )
 {
 PCB_VIA* via = static_cast<PCB_VIA*>( aItem );
 pos = via->GetPosition();

 if( via->GetLayerSet().Contains( aLayer ) )
 holeShape.reset( new SHAPE_SEGMENT( pos, pos, via->GetDrill() ) );
 }
 else if( aItem->Type() == PCB_PAD_T )
 {
 PAD* pad = static_cast<PAD*>( aItem );

 if( pad->GetDrillSize().x )
 holeShape.reset( new SHAPE_SEGMENT( *pad->GetEffectiveHoleShape() ) );
 }

 if( holeShape )
 {
 constraint = m_drcEngine->EvalRules( HOLE_CLEARANCE_CONSTRAINT, aItem, zone,
 aLayer );
 clearance = constraint.GetValue().Min();

 if( zoneTree && zoneTree->QueryColliding( itemBBox, holeShape.get(), aLayer,
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_HOLE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( aItem, zone );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );
 }
 }
 }
 }
 }
}

References _, CLEARANCE_CONSTRAINT, DRC_ITEM::Create(), DRCE_CLEARANCE, DRCE_HOLE_CLEARANCE, DRC_ENGINE::EvalRules(), EDA_ITEM::GetBoundingBox(), BOARD::GetDesignSettings(), BOARD_ITEM::GetEffectiveShape(), BOARD_DESIGN_SETTINGS::GetHolePlatingThickness(), DRC_CONSTRAINT::GetName(), DRC_CONSTRAINT::GetParentRule(), SHAPE_SEGMENT::GetSeg(), DRC_CONSTRAINT::GetValue(), SHAPE_SEGMENT::GetWidth(), HOLE_CLEARANCE_CONSTRAINT, EDA_RECT::Intersects(), BOARD_ITEM::IsConnected(), DRC_ENGINE::IsErrorLimitExceeded(), DRC_TEST_PROVIDER_CLEARANCE_BASE::m_board, BOARD::m_CopperZoneRTrees, DRC_TEST_PROVIDER::m_drcEngine, m_drcEpsilon, m_zones, MessageTextFromValue(), MINOPTMAX< T >::Min(), pad, PCB_PAD_T, PCB_VIA_T, PTH, DRC_RTREE::QueryColliding(), DRC_TEST_PROVIDER::reportViolation(), EDA_ITEM::Type(), DRC_TEST_PROVIDER::userUnits(), and via.

Referenced by testPadClearances(), and testTrackClearances().

testPadAgainstItem()

bool DRC_TEST_PROVIDER_COPPER_CLEARANCE::testPadAgainstItem ( PAD *  pad, SHAPE *  padShape, PCB_LAYER_ID  layer, BOARD_ITEM *  other  )

private

Definition at line 577 of file drc_test_provider_copper_clearance.cpp.

{
 bool testClearance = !m_drcEngine->IsErrorLimitExceeded( DRCE_CLEARANCE );
 bool testShorting = !m_drcEngine->IsErrorLimitExceeded( DRCE_SHORTING_ITEMS );
 bool testHoles = !m_drcEngine->IsErrorLimitExceeded( DRCE_HOLE_CLEARANCE );

 // Disable some tests *within* a single footprint
 if( other->GetParent() == pad->GetParent() )
 {
 FOOTPRINT* fp = static_cast<FOOTPRINT*>( pad->GetParent() );

 // Graphic items are allowed to act as net-ties within their own footprint
 if( fp->IsNetTie() && ( other->Type() == PCB_FP_SHAPE_T || other->Type() == PCB_PAD_T ) )
 testClearance = false;

 // No hole testing within a footprint
 testHoles = false;
 }

 PAD* otherPad = nullptr;
 PCB_VIA* otherVia = nullptr;

 if( other->Type() == PCB_PAD_T )
 otherPad = static_cast<PAD*>( other );

 if( other->Type() == PCB_VIA_T )
 otherVia = static_cast<PCB_VIA*>( other );

 if( !IsCopperLayer( layer ) )
 testClearance = false;

 // A NPTH has no cylinder, but it may still have pads on some layers
 if( pad->GetAttribute() == PAD_ATTRIB::NPTH && !pad->FlashLayer( layer ) )
 testClearance = false;

 if( otherPad && otherPad->GetAttribute() == PAD_ATTRIB::NPTH && !otherPad->FlashLayer( layer ) )
 testClearance = false;

 // Track clearances are tested in testTrackClearances()
 if( dynamic_cast<PCB_TRACK*>( other) )
 testClearance = false;

 int padNet = pad->GetNetCode();
 int otherPadNet = otherPad ? otherPad->GetNetCode() : 0;
 int otherViaNet = otherVia ? otherVia->GetNetCode() : 0;

 // Pads and vias of the same (defined) net get a waiver on clearance and hole tests
 if( ( otherPadNet && otherPadNet == padNet ) || ( otherViaNet && otherViaNet == padNet ) )
 {
 testClearance = false;
 testHoles = false;
 }

 if( !( pad->GetDrillSize().x > 0 )
 && !( otherPad && otherPad->GetDrillSize().x > 0 )
 && !( otherVia && otherVia->GetDrill() > 0 ) )
 {
 testHoles = false;
 }

 if( !testClearance && !testShorting && !testHoles )
 return false;

 std::shared_ptr<SHAPE> otherShape = DRC_ENGINE::GetShape( other, layer );
 DRC_CONSTRAINT constraint;
 int clearance;
 int actual;
 VECTOR2I pos;

 if( otherPad && pad->SameLogicalPadAs( otherPad ) )
 {
 // If pads are equivalent (ie: from the same footprint with the same pad number)...
 // ... and have nets...
 // then they must be the same net
 if( pad->GetNetCode() && otherPad->GetNetCode()
 && pad->GetNetCode() != otherPad->GetNetCode()
 && testShorting )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_SHORTING_ITEMS );
 wxString msg;

 msg.Printf( _( "(nets %s and %s)" ),
 pad->GetNetname(),
 otherPad->GetNetname() );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( pad, otherPad );

 reportViolation( drce, otherPad->GetPosition() );
 }

 return true;
 }

 if( testClearance )
 {
 constraint = m_drcEngine->EvalRules( CLEARANCE_CONSTRAINT, pad, other, layer );
 clearance = constraint.GetValue().Min();

 if( clearance > 0 && padShape->Collide( otherShape.get(),
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( pad, other );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );
 testHoles = false; // No need for multiple violations
 }
 }

 if( testHoles )
 {
 constraint = m_drcEngine->EvalRules( HOLE_CLEARANCE_CONSTRAINT, pad, other, layer );
 clearance = constraint.GetValue().Min();
 }

 if( testHoles && otherPad && pad->FlashLayer( layer ) && otherPad->GetDrillSize().x )
 {
 if( clearance > 0 && padShape->Collide( otherPad->GetEffectiveHoleShape(),
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_HOLE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( pad, other );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );
 testHoles = false; // No need for multiple violations
 }
 }

 if( testHoles && otherPad && otherPad->FlashLayer( layer ) && pad->GetDrillSize().x )
 {
 if( clearance >= 0 && otherShape->Collide( pad->GetEffectiveHoleShape(),
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_HOLE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( pad, other );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );
 testHoles = false; // No need for multiple violations
 }
 }

 if( testHoles && otherVia && otherVia->IsOnLayer( layer ) )
 {
 pos = otherVia->GetPosition();
 otherShape.reset( new SHAPE_SEGMENT( pos, pos, otherVia->GetDrill() ) );

 if( clearance > 0 && padShape->Collide( otherShape.get(),
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_HOLE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( pad, otherVia );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );
 }
 }

 return true;
}

References _, CLEARANCE_CONSTRAINT, SHAPE::Collide(), DRC_ITEM::Create(), DRCE_CLEARANCE, DRCE_HOLE_CLEARANCE, DRCE_SHORTING_ITEMS, DRC_ENGINE::EvalRules(), PAD::FlashLayer(), PAD::GetAttribute(), PCB_VIA::GetDrill(), PAD::GetDrillSize(), PAD::GetEffectiveHoleShape(), DRC_CONSTRAINT::GetName(), BOARD_CONNECTED_ITEM::GetNetCode(), BOARD_CONNECTED_ITEM::GetNetname(), BOARD_ITEM::GetParent(), DRC_CONSTRAINT::GetParentRule(), PAD::GetPosition(), PCB_VIA::GetPosition(), DRC_ENGINE::GetShape(), DRC_CONSTRAINT::GetValue(), HOLE_CLEARANCE_CONSTRAINT, IsCopperLayer(), DRC_ENGINE::IsErrorLimitExceeded(), FOOTPRINT::IsNetTie(), PCB_VIA::IsOnLayer(), DRC_TEST_PROVIDER::m_drcEngine, m_drcEpsilon, MessageTextFromValue(), MINOPTMAX< T >::Min(), NPTH, pad, PCB_FP_SHAPE_T, PCB_PAD_T, PCB_VIA_T, DRC_TEST_PROVIDER::reportViolation(), EDA_ITEM::Type(), and DRC_TEST_PROVIDER::userUnits().

Referenced by testPadClearances().

testPadClearances()

void DRC_TEST_PROVIDER_COPPER_CLEARANCE::testPadClearances ( )

private

Definition at line 780 of file drc_test_provider_copper_clearance.cpp.

{
 const int delta = 50; // This is the number of tests between 2 calls to the progress bar

 size_t count = 0;

 for( FOOTPRINT* footprint : m_board->Footprints() )
 count += footprint->Pads().size();

 reportAux( wxT( "Testing %d pads..." ), count );

 int ii = 0;
 std::map< std::pair<BOARD_ITEM*, BOARD_ITEM*>, int> checkedPairs;

 for( FOOTPRINT* footprint : m_board->Footprints() )
 {
 for( PAD* pad : footprint->Pads() )
 {
 if( !reportProgress( ii++, count, delta ) )
 break;

 for( PCB_LAYER_ID layer : pad->GetLayerSet().Seq() )
 {
 std::shared_ptr<SHAPE> padShape = DRC_ENGINE::GetShape( pad, layer );

 m_copperTree.QueryColliding( pad, layer, layer,
 // Filter:
 [&]( BOARD_ITEM* other ) -> bool
 {
 BOARD_ITEM* a = pad;
 BOARD_ITEM* b = other;

 // store canonical order so we don't collide in both directions
 // (a:b and b:a)
 if( static_cast<void*>( a ) > static_cast<void*>( b ) )
 std::swap( a, b );

 if( checkedPairs.count( { a, b } ) )
 {
 return false;
 }
 else
 {
 checkedPairs[ { a, b } ] = 1;
 return true;
 }
 },
 // Visitor
 [&]( BOARD_ITEM* other ) -> bool
 {
 return testPadAgainstItem( pad, padShape.get(), layer, other );
 },
 m_largestClearance );

 testItemAgainstZones( pad, layer );
 }
 }
 }
}

References delta, BOARD::Footprints(), DRC_ENGINE::GetShape(), DRC_TEST_PROVIDER_CLEARANCE_BASE::m_board, m_copperTree, DRC_TEST_PROVIDER_CLEARANCE_BASE::m_largestClearance, pad, DRC_RTREE::QueryColliding(), DRC_TEST_PROVIDER::reportAux(), DRC_TEST_PROVIDER::reportProgress(), testItemAgainstZones(), and testPadAgainstItem().

Referenced by Run().

testTrackAgainstItem()

bool DRC_TEST_PROVIDER_COPPER_CLEARANCE::testTrackAgainstItem ( PCB_TRACK *  track, SHAPE *  trackShape, PCB_LAYER_ID  layer, BOARD_ITEM *  other  )

private

Definition at line 260 of file drc_test_provider_copper_clearance.cpp.

{
 bool testClearance = !m_drcEngine->IsErrorLimitExceeded( DRCE_CLEARANCE );
 bool testHoles = !m_drcEngine->IsErrorLimitExceeded( DRCE_HOLE_CLEARANCE );
 DRC_CONSTRAINT constraint;
 int clearance = -1;
 int actual;
 VECTOR2I pos;

 if( other->Type() == PCB_PAD_T )
 {
 PAD* pad = static_cast<PAD*>( other );

 if( pad->GetAttribute() == PAD_ATTRIB::NPTH && !pad->FlashLayer( layer ) )
 testClearance = false;
 }

 if( testClearance )
 {
 constraint = m_drcEngine->EvalRules( CLEARANCE_CONSTRAINT, track, other, layer );
 clearance = constraint.GetValue().Min();
 }

 if( clearance >= 0 )
 {
 // Special processing for track:track intersections
 if( track->Type() == PCB_TRACE_T && other->Type() == PCB_TRACE_T )
 {
 SEG trackSeg( track->GetStart(), track->GetEnd() );
 SEG otherSeg( track->GetStart(), track->GetEnd() );

 if( OPT_VECTOR2I intersection = trackSeg.Intersect( otherSeg ) )
 {
 std::shared_ptr<DRC_ITEM> drcItem = DRC_ITEM::Create( DRCE_TRACKS_CROSSING );
 drcItem->SetItems( track, other );
 drcItem->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drcItem, (wxPoint) intersection.get() );

 return m_drcEngine->GetReportAllTrackErrors();
 }
 }

 std::shared_ptr<SHAPE> otherShape = DRC_ENGINE::GetShape( other, layer );

 if( trackShape->Collide( otherShape.get(), clearance - m_drcEpsilon, &actual, &pos ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( track, other );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );

 if( !m_drcEngine->GetReportAllTrackErrors() )
 return false;
 }
 }

 if( testHoles && ( other->Type() == PCB_VIA_T || other->Type() == PCB_PAD_T ) )
 {
 std::unique_ptr<SHAPE_SEGMENT> holeShape;

 if( other->Type() == PCB_VIA_T )
 {
 PCB_VIA* via = static_cast<PCB_VIA*>( other );
 pos = via->GetPosition();

 if( via->GetLayerSet().Contains( layer ) )
 holeShape.reset( new SHAPE_SEGMENT( pos, pos, via->GetDrill() ) );
 }
 else if( other->Type() == PCB_PAD_T )
 {
 PAD* pad = static_cast<PAD*>( other );

 if( pad->GetDrillSize().x )
 holeShape.reset( new SHAPE_SEGMENT( *pad->GetEffectiveHoleShape() ) );
 }

 if( holeShape )
 {
 constraint = m_drcEngine->EvalRules( HOLE_CLEARANCE_CONSTRAINT, other, track, layer );
 clearance = constraint.GetValue().Min();

 if( clearance > 0 && trackShape->Collide( holeShape.get(),
 std::max( 0, clearance - m_drcEpsilon ),
 &actual, &pos ) )
 {

 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_HOLE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), clearance ),
 MessageTextFromValue( userUnits(), actual ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 drce->SetItems( track, other );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, (wxPoint) pos );

 if( !m_drcEngine->GetReportAllTrackErrors() )
 return false;
 }
 }
 }

 return true;
}

References _, CLEARANCE_CONSTRAINT, SHAPE::Collide(), DRC_ITEM::Create(), DRCE_CLEARANCE, DRCE_HOLE_CLEARANCE, DRCE_TRACKS_CROSSING, DRC_ENGINE::EvalRules(), PCB_TRACK::GetEnd(), DRC_CONSTRAINT::GetName(), DRC_CONSTRAINT::GetParentRule(), DRC_ENGINE::GetReportAllTrackErrors(), DRC_ENGINE::GetShape(), PCB_TRACK::GetStart(), DRC_CONSTRAINT::GetValue(), HOLE_CLEARANCE_CONSTRAINT, DRC_ENGINE::IsErrorLimitExceeded(), DRC_TEST_PROVIDER::m_drcEngine, m_drcEpsilon, MessageTextFromValue(), MINOPTMAX< T >::Min(), NPTH, pad, PCB_PAD_T, PCB_TRACE_T, PCB_VIA_T, DRC_TEST_PROVIDER::reportViolation(), EDA_ITEM::Type(), DRC_TEST_PROVIDER::userUnits(), and via.

Referenced by testTrackClearances().

testTrackClearances()

void DRC_TEST_PROVIDER_COPPER_CLEARANCE::testTrackClearances ( )

private

Definition at line 513 of file drc_test_provider_copper_clearance.cpp.

{
 // This is the number of tests between 2 calls to the progress bar
 const int delta = 100;
 int ii = 0;

 reportAux( wxT( "Testing %d tracks & vias..." ), m_board->Tracks().size() );

 std::map< std::pair<BOARD_ITEM*, BOARD_ITEM*>, int> checkedPairs;

 for( PCB_TRACK* track : m_board->Tracks() )
 {
 if( !reportProgress( ii++, m_board->Tracks().size(), delta ) )
 break;

 for( PCB_LAYER_ID layer : track->GetLayerSet().Seq() )
 {
 std::shared_ptr<SHAPE> trackShape = track->GetEffectiveShape( layer );

 m_copperTree.QueryColliding( track, layer, layer,
 // Filter:
 [&]( BOARD_ITEM* other ) -> bool
 {
 // It would really be better to know what particular nets a nettie
 // should allow, but for now it is what it is.
 if( DRC_ENGINE::IsNetTie( other ) )
 return false;

 auto otherCItem = dynamic_cast<BOARD_CONNECTED_ITEM*>( other );

 if( otherCItem && otherCItem->GetNetCode() == track->GetNetCode() )
 return false;

 BOARD_ITEM* a = track;
 BOARD_ITEM* b = other;

 // store canonical order so we don't collide in both directions
 // (a:b and b:a)
 if( static_cast<void*>( a ) > static_cast<void*>( b ) )
 std::swap( a, b );

 if( checkedPairs.count( { a, b } ) )
 {
 return false;
 }
 else
 {
 checkedPairs[ { a, b } ] = 1;
 return true;
 }
 },
 // Visitor:
 [&]( BOARD_ITEM* other ) -> bool
 {
 return testTrackAgainstItem( track, trackShape.get(), layer, other );
 },
 m_largestClearance );

 testItemAgainstZones( track, layer );
 }
 }
}

References delta, DRC_ENGINE::IsNetTie(), DRC_TEST_PROVIDER_CLEARANCE_BASE::m_board, m_copperTree, DRC_TEST_PROVIDER_CLEARANCE_BASE::m_largestClearance, DRC_RTREE::QueryColliding(), DRC_TEST_PROVIDER::reportAux(), DRC_TEST_PROVIDER::reportProgress(), testItemAgainstZones(), testTrackAgainstItem(), and BOARD::Tracks().

Referenced by Run().

testZonesToZones()

void DRC_TEST_PROVIDER_COPPER_CLEARANCE::testZonesToZones ( )

private

Definition at line 841 of file drc_test_provider_copper_clearance.cpp.

{
 const int delta = 50; // This is the number of tests between 2 calls to the progress bar

 SHAPE_POLY_SET buffer;
 SHAPE_POLY_SET* boardOutline = nullptr;

 if( m_board->GetBoardPolygonOutlines( buffer ) )
 boardOutline = &buffer;

 for( int layer_id = F_Cu; layer_id <= B_Cu; ++layer_id )
 {
 PCB_LAYER_ID layer = static_cast<PCB_LAYER_ID>( layer_id );
 std::vector<SHAPE_POLY_SET> smoothed_polys;
 smoothed_polys.resize( m_zones.size() );

 // Skip over layers not used on the current board
 if( !m_board->IsLayerEnabled( layer ) )
 continue;

 for( size_t ii = 0; ii < m_zones.size(); ii++ )
 {
 if( m_zones[ii]->IsOnLayer( layer ) )
 m_zones[ii]->BuildSmoothedPoly( smoothed_polys[ii], layer, boardOutline );
 }

 // iterate through all areas
 for( size_t ia = 0; ia < m_zones.size(); ia++ )
 {
 if( !reportProgress( layer_id * m_zones.size() + ia, B_Cu * m_zones.size(), delta ) )
 break;

 ZONE* zoneRef = m_zones[ia];

 if( !zoneRef->IsOnLayer( layer ) )
 continue;

 // If we are testing a single zone, then iterate through all other zones
 // Otherwise, we have already tested the zone combination
 for( size_t ia2 = ia + 1; ia2 < m_zones.size(); ia2++ )
 {
 ZONE* zoneToTest = m_zones[ia2];

 if( zoneRef == zoneToTest )
 continue;

 // test for same layer
 if( !zoneToTest->IsOnLayer( layer ) )
 continue;

 // Test for same net
 if( zoneRef->GetNetCode() == zoneToTest->GetNetCode()
 && zoneRef->GetNetCode() >= 0 )
 continue;

 // test for different priorities
 if( zoneRef->GetPriority() != zoneToTest->GetPriority() )
 continue;

 // rule areas may overlap at will
 if( zoneRef->GetIsRuleArea() || zoneToTest->GetIsRuleArea() )
 continue;

 // Examine a candidate zone: compare zoneToTest to zoneRef

 // Get clearance used in zone to zone test.
 auto constraint = m_drcEngine->EvalRules( CLEARANCE_CONSTRAINT, zoneRef, zoneToTest,
 layer );
 int zone2zoneClearance = constraint.GetValue().Min();

 // test for some corners of zoneRef inside zoneToTest
 for( auto iterator = smoothed_polys[ia].IterateWithHoles(); iterator; iterator++ )
 {
 VECTOR2I currentVertex = *iterator;
 wxPoint pt( currentVertex.x, currentVertex.y );

 if( smoothed_polys[ia2].Contains( currentVertex ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_ZONES_INTERSECT );
 drce->SetItems( zoneRef, zoneToTest );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, pt );
 }
 }

 // test for some corners of zoneToTest inside zoneRef
 for( auto iterator = smoothed_polys[ia2].IterateWithHoles(); iterator; iterator++ )
 {
 VECTOR2I currentVertex = *iterator;
 wxPoint pt( currentVertex.x, currentVertex.y );

 if( smoothed_polys[ia].Contains( currentVertex ) )
 {
 std::shared_ptr<DRC_ITEM> drce = DRC_ITEM::Create( DRCE_ZONES_INTERSECT );
 drce->SetItems( zoneToTest, zoneRef );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, pt );
 }
 }

 // Iterate through all the segments of refSmoothedPoly
 std::map<wxPoint, int> conflictPoints;

 for( auto refIt = smoothed_polys[ia].IterateSegmentsWithHoles(); refIt; refIt++ )
 {
 // Build ref segment
 SEG refSegment = *refIt;

 // Iterate through all the segments in smoothed_polys[ia2]
 for( auto testIt = smoothed_polys[ia2].IterateSegmentsWithHoles(); testIt; testIt++ )
 {
 // Build test segment
 SEG testSegment = *testIt;
  wxPoint pt;

 int ax1, ay1, ax2, ay2;
 ax1 = refSegment.A.x;
 ay1 = refSegment.A.y;
 ax2 = refSegment.B.x;
 ay2 = refSegment.B.y;

 int bx1, by1, bx2, by2;
 bx1 = testSegment.A.x;
 by1 = testSegment.A.y;
 bx2 = testSegment.B.x;
 by2 = testSegment.B.y;

 int d = GetClearanceBetweenSegments( bx1, by1, bx2, by2,
 0,
 ax1, ay1, ax2, ay2,
 0,
 zone2zoneClearance,
 &pt.x, &pt.y );

 if( d < zone2zoneClearance )
 {
 if( conflictPoints.count( pt ) )
 conflictPoints[ pt ] = std::min( conflictPoints[ pt ], d );
 else
 conflictPoints[ pt ] = d;
 }
 }
 }

 for( const std::pair<const wxPoint, int>& conflict : conflictPoints )
 {
 int actual = conflict.second;
 std::shared_ptr<DRC_ITEM> drce;

 if( actual <= 0 )
 {
 drce = DRC_ITEM::Create( DRCE_ZONES_INTERSECT );
 }
 else
 {
 drce = DRC_ITEM::Create( DRCE_CLEARANCE );
 wxString msg;

 msg.Printf( _( "(%s clearance %s; actual %s)" ),
 constraint.GetName(),
 MessageTextFromValue( userUnits(), zone2zoneClearance ),
 MessageTextFromValue( userUnits(), conflict.second ) );

 drce->SetErrorMessage( drce->GetErrorText() + wxS( " " ) + msg );
 }

 drce->SetItems( zoneRef, zoneToTest );
 drce->SetViolatingRule( constraint.GetParentRule() );

 reportViolation( drce, conflict.first );
 }
 }
 }
 }
}

References _, SEG::A, SEG::B, B_Cu, CLEARANCE_CONSTRAINT, DRC_ITEM::Create(), delta, DRCE_CLEARANCE, DRCE_ZONES_INTERSECT, DRC_ENGINE::EvalRules(), F_Cu, BOARD::GetBoardPolygonOutlines(), ZONE::GetIsRuleArea(), BOARD_CONNECTED_ITEM::GetNetCode(), ZONE::GetPriority(), DRC_CONSTRAINT::GetValue(), BOARD::IsLayerEnabled(), ZONE::IsOnLayer(), DRC_TEST_PROVIDER_CLEARANCE_BASE::m_board, DRC_TEST_PROVIDER::m_drcEngine, m_zones, MessageTextFromValue(), MINOPTMAX< T >::Min(), DRC_TEST_PROVIDER::reportProgress(), DRC_TEST_PROVIDER::reportViolation(), DRC_TEST_PROVIDER::userUnits(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Run().

userUnits()

EDA_UNITS DRC_TEST_PROVIDER::userUnits ( ) const

protectedinherited

Definition at line 97 of file drc_test_provider.cpp.

{
 return m_drcEngine->UserUnits();
}

References DRC_TEST_PROVIDER::m_drcEngine, and DRC_ENGINE::UserUnits().

Referenced by DRC_TEST_PROVIDER_MATCHED_LENGTH::checkLengths(), DRC_TEST_PROVIDER_HOLE_SIZE::checkPad(), DRC_TEST_PROVIDER_MATCHED_LENGTH::checkSkews(), DRC_TEST_PROVIDER_HOLE_SIZE::checkVia(), DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), DRC_TEST_PROVIDER_MATCHED_LENGTH::runInternal(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::testAgainstEdge(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::testHoleAgainstHole(), testItemAgainstZones(), testPadAgainstItem(), testTrackAgainstItem(), and testZonesToZones().

Member Data Documentation

m_board

BOARD* DRC_TEST_PROVIDER_CLEARANCE_BASE::m_board

protectedinherited

Definition at line 51 of file drc_test_provider_clearance_base.h.

Referenced by DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), Run(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testFootprintCourtyardDefinitions(), testItemAgainstZones(), testPadClearances(), testTrackClearances(), and testZonesToZones().

m_boardOutlineValid

bool DRC_TEST_PROVIDER_CLEARANCE_BASE::m_boardOutlineValid

protectedinherited

Definition at line 53 of file drc_test_provider_clearance_base.h.

m_copperTree

DRC_RTREE DRC_TEST_PROVIDER_COPPER_CLEARANCE::m_copperTree

private

Definition at line 100 of file drc_test_provider_copper_clearance.cpp.

Referenced by Run(), testPadClearances(), and testTrackClearances().

m_drcEngine

DRC_ENGINE* DRC_TEST_PROVIDER::m_drcEngine

protectedinherited

Definition at line 131 of file drc_test_provider.h.

Referenced by DRC_TEST_PROVIDER_HOLE_SIZE::checkPad(), DRC_TEST_PROVIDER_HOLE_SIZE::checkVia(), DRC_TEST_PROVIDER::forEachGeometryItem(), DRC_TEST_PROVIDER_LVS::GetNumPhases(), DRC_TEST_PROVIDER::reportAux(), DRC_TEST_PROVIDER::reportPhase(), DRC_TEST_PROVIDER::reportProgress(), DRC_TEST_PROVIDER::reportRuleStatistics(), DRC_TEST_PROVIDER::reportViolation(), DRC_TEST_PROVIDER_VIA_DIAMETER::Run(), DRC_TEST_PROVIDER_TRACK_WIDTH::Run(), DRC_TEST_PROVIDER_DISALLOW::Run(), DRC_TEST_PROVIDER_HOLE_SIZE::Run(), DRC_TEST_PROVIDER_ANNULAR_WIDTH::Run(), DRC_TEST_PROVIDER_CONNECTIVITY::Run(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::Run(), DRC_TEST_PROVIDER_MISC::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), DRC_TEST_PROVIDER_LVS::Run(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), Run(), DRC_TEST_PROVIDER_MATCHED_LENGTH::runInternal(), DRC_TEST_PROVIDER::SetDRCEngine(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::testAgainstEdge(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), DRC_TEST_PROVIDER_MISC::testDisabledLayers(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testFootprintCourtyardDefinitions(), DRC_TEST_PROVIDER_LVS::testFootprints(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::testHoleAgainstHole(), testItemAgainstZones(), testPadAgainstItem(), DRC_TEST_PROVIDER_MISC::testTextVars(), testTrackAgainstItem(), testZonesToZones(), and DRC_TEST_PROVIDER::userUnits().

m_drcEpsilon

int DRC_TEST_PROVIDER_COPPER_CLEARANCE::m_drcEpsilon

private

Definition at line 101 of file drc_test_provider_copper_clearance.cpp.

Referenced by Run(), testItemAgainstZones(), testPadAgainstItem(), and testTrackAgainstItem().

m_enabled

bool DRC_TEST_PROVIDER::m_enabled = true

protectedinherited

Definition at line 134 of file drc_test_provider.h.

Referenced by DRC_TEST_PROVIDER::Enable(), and DRC_TEST_PROVIDER::IsEnabled().

m_isRuleDriven

bool DRC_TEST_PROVIDER::m_isRuleDriven = true

protectedinherited

Definition at line 133 of file drc_test_provider.h.

Referenced by DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::DRC_TEST_PROVIDER_COURTYARD_CLEARANCE(), DRC_TEST_PROVIDER_LVS::DRC_TEST_PROVIDER_LVS(), DRC_TEST_PROVIDER_MISC::DRC_TEST_PROVIDER_MISC(), DRC_TEST_PROVIDER::IsRuleDriven(), and DRC_TEST_PROVIDER::reportRuleStatistics().

m_largestClearance

int DRC_TEST_PROVIDER_CLEARANCE_BASE::m_largestClearance

protectedinherited

Definition at line 52 of file drc_test_provider_clearance_base.h.

Referenced by DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::Run(), DRC_TEST_PROVIDER_HOLE_TO_HOLE::Run(), DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run(), Run(), DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testCourtyardClearances(), testPadClearances(), and testTrackClearances().

m_stats

std::unordered_map<const DRC_RULE*, int> DRC_TEST_PROVIDER::m_stats

protectedinherited

Definition at line 132 of file drc_test_provider.h.

Referenced by DRC_TEST_PROVIDER::accountCheck(), DRC_TEST_PROVIDER::reportRuleStatistics(), and DRC_TEST_PROVIDER::SetDRCEngine().

m_zones

std::vector<ZONE*> DRC_TEST_PROVIDER_COPPER_CLEARANCE::m_zones

private

Definition at line 103 of file drc_test_provider_copper_clearance.cpp.

Referenced by Run(), testItemAgainstZones(), and testZonesToZones().

s_allBasicItems

std::vector< KICAD_T > DRC_TEST_PROVIDER::s_allBasicItems

staticprotectedinherited

Definition at line 127 of file drc_test_provider.h.

Referenced by DRC_TEST_PROVIDER::forEachGeometryItem(), DRC_TEST_PROVIDER_SILK_TO_MASK::Run(), DRC_TEST_PROVIDER_SILK_CLEARANCE::Run(), and DRC_TEST_PROVIDER_MISC::testDisabledLayers().

s_allBasicItemsButZones

std::vector< KICAD_T > DRC_TEST_PROVIDER::s_allBasicItemsButZones

staticprotectedinherited

Definition at line 128 of file drc_test_provider.h.

Referenced by DRC_TEST_PROVIDER::forEachGeometryItem(), and DRC_TEST_PROVIDER_EDGE_CLEARANCE::Run().

---

The documentation for this class was generated from the following file:

• drc_test_provider_copper_clearance.cpp