drc_rtree.h

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.
 * Copyright (C) 2020 CERN
 *
 * 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 <https://www.gnu.org/licenses/>.
 */
 
#ifndef DRC_RTREE_H_
#define DRC_RTREE_H_
 
#include <board_item.h>
#include <pcb_field.h>
#include <algorithm>
#include <memory>
#include <unordered_set>
#include <set>
#include <vector>
 
#include <geometry/rtree/packed_rtree.h>
#include <geometry/shape.h>
#include <geometry/shape_segment.h>
#include <math/vector2d.h>
#include "geometry/shape_null.h"
#include "board.h"
 
#define ATOMIC_TABLES true

class DRC_RTREE
{
public:
    struct ITEM_WITH_SHAPE
    {
        ITEM_WITH_SHAPE( BOARD_ITEM *aParent, const SHAPE* aShape,
                         std::shared_ptr<SHAPE> aParentShape ) :
            parent( aParent ),
            shape( aShape ),
            shapeStorage( nullptr ),
            parentShape( std::move( aParentShape ) )
        {};
 
        ITEM_WITH_SHAPE( BOARD_ITEM *aParent, const std::shared_ptr<SHAPE>& aShape,
                         std::shared_ptr<SHAPE> aParentShape ) :
            parent( aParent ),
            shape( aShape.get() ),
            shapeStorage( aShape ),
            parentShape( std::move( aParentShape ) )
        {};
 
        BOARD_ITEM*            parent;
        const SHAPE*           shape;
        std::shared_ptr<SHAPE> shapeStorage;

        std::shared_ptr<SHAPE> parentShape;
    };
 
private:
    using drc_rtree = KIRTREE::PACKED_RTREE<ITEM_WITH_SHAPE*, int, 2>;
    using drc_rtree_builder = typename drc_rtree::Builder;
 
public:
    DRC_RTREE()
    {
        m_count = 0;
    }
 
    ~DRC_RTREE()
    {
        for( ITEM_WITH_SHAPE* p : m_owned )
            delete p;
    }

    void Insert( BOARD_ITEM* aItem, PCB_LAYER_ID aLayer, DRC_CONSTRAINT_T aConstraintType,
                 int aWorstClearance = 0, bool aAtomicTables = false )
    {
        Insert( aItem, aLayer, aLayer, aConstraintType, aWorstClearance, aAtomicTables );
    }

    void Insert( BOARD_ITEM* aItem, PCB_LAYER_ID aRefLayer, PCB_LAYER_ID aTargetLayer,
                 DRC_CONSTRAINT_T aConstraintType, int aWorstClearance, bool aAtomicTables = false )
    {
        wxCHECK( aTargetLayer != UNDEFINED_LAYER, /* void */ );
        wxCHECK_MSG( !m_tree.count( aTargetLayer ), /* void */, wxT( "Insert after Build() is silently wrong" ) );
 
        if( aItem->Type() == PCB_FIELD_T && !static_cast<PCB_FIELD*>( aItem )->IsVisible() )
            return;
 
        BOARD_ITEM* parent = aItem;
 
        if( aAtomicTables && aItem->Type() == PCB_TABLECELL_T )
            parent = aItem->GetParent();
 
        std::vector<const SHAPE*> subshapes;
        std::shared_ptr<SHAPE> shape = aItem->GetEffectiveShape( aRefLayer, FLASHING::DEFAULT, aConstraintType );
 
        wxCHECK2_MSG( shape, return, wxT( "Item does not have a valid shape for this layer" ) );
 
        if( shape->HasIndexableSubshapes() )
            shape->GetIndexableSubshapes( subshapes );
        else
            subshapes.push_back( shape.get() );
 
        for( const SHAPE* subshape : subshapes )
        {
            if( dynamic_cast<const SHAPE_NULL*>( subshape ) )
                continue;
 
            BOX2I bbox = subshape->BBox();
 
            bbox.Inflate( aWorstClearance );
 
            const int        mmin[2] = { bbox.GetX(), bbox.GetY() };
            const int        mmax[2] = { bbox.GetRight(), bbox.GetBottom() };
            ITEM_WITH_SHAPE* itemShape = new ITEM_WITH_SHAPE( parent, subshape, shape );
 
            m_owned.push_back( itemShape );
            m_builders[aTargetLayer].Add( mmin, mmax, itemShape );
            recordPadding( aTargetLayer, aWorstClearance );
            m_count++;
        }
 
        if( aItem->Type() == PCB_PAD_T && aItem->HasHole() )
        {
            std::shared_ptr<SHAPE_SEGMENT> hole = aItem->GetEffectiveHoleShape();
            BOX2I                          bbox = hole->BBox();
 
            bbox.Inflate( aWorstClearance );
 
            const int        mmin[2] = { bbox.GetX(), bbox.GetY() };
            const int        mmax[2] = { bbox.GetRight(), bbox.GetBottom() };
            ITEM_WITH_SHAPE* itemShape = new ITEM_WITH_SHAPE( parent, hole, shape );
 
            m_owned.push_back( itemShape );
            m_builders[aTargetLayer].Add( mmin, mmax, itemShape );
            recordPadding( aTargetLayer, aWorstClearance );
            m_count++;
        }
    }

    void Build()
    {
        for( auto& [layer, builder] : m_builders )
            m_tree[layer] = builder.Build();
 
        m_builders.clear();
    }

    void clear()
    {
        for( ITEM_WITH_SHAPE* p : m_owned )
            delete p;
 
        m_owned.clear();
        m_tree.clear();
        m_builders.clear();
        m_minPadding.clear();
        m_count = 0;
    }
 
    bool CheckColliding( SHAPE* aRefShape, PCB_LAYER_ID aTargetLayer, int aClearance = 0,
                         std::function<bool( BOARD_ITEM*)> aFilter = nullptr ) const
    {
        BOX2I box = aRefShape->BBox();
        box.Inflate( aClearance );
 
        int min[2] = { box.GetX(),         box.GetY() };
        int max[2] = { box.GetRight(),     box.GetBottom() };
 
        int count = 0;
 
        auto visit =
                [&] ( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    if( !aFilter || aFilter( aItem->parent ) )
                    {
                        int actual;
 
                        if( aRefShape->Collide( aItem->shape, aClearance, &actual ) )
                        {
                            count++;
                            return false;
                        }
                    }
 
                    return true;
                };
 
        if( auto it = m_tree.find( aTargetLayer ); it != m_tree.end() )
            it->second.Search( min, max, visit );
 
        return count > 0;
    }

    bool CheckColliding( SHAPE* aRefShape, PCB_LAYER_ID aTargetLayer, int aMaxClearance,
                         const std::function<bool( BOARD_ITEM*, int* )>& aClearanceResolver ) const
    {
        BOX2I box = aRefShape->BBox();
        box.Inflate( aMaxClearance );
 
        int min[2] = { box.GetX(),     box.GetY() };
        int max[2] = { box.GetRight(), box.GetBottom() };
 
        bool collision = false;
 
        // Compound and triangulated items are visited once per subshape, but the clearance is
        // a property of the item.
        std::unordered_map<BOARD_ITEM*, std::pair<bool, int>> resolved;
 
        auto visit =
                [&] ( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    auto it = resolved.find( aItem->parent );
 
                    if( it == resolved.end() )
                    {
                        int  clearance = 0;
                        bool test = aClearanceResolver( aItem->parent, &clearance );
 
                        it = resolved.emplace( aItem->parent,
                                               std::make_pair( test, clearance ) ).first;
                    }
 
                    if( !it->second.first )
                        return true;
 
                    if( aRefShape->Collide( aItem->shape, it->second.second ) )
                    {
                        collision = true;
                        return false;
                    }
 
                    return true;
                };
 
        if( auto it = m_tree.find( aTargetLayer ); it != m_tree.end() )
            it->second.Search( min, max, visit );
 
        return collision;
    }

    int QueryColliding( BOARD_ITEM* aRefItem, PCB_LAYER_ID aRefLayer, PCB_LAYER_ID aTargetLayer,
                        std::function<bool( BOARD_ITEM* )> aFilter = nullptr,
                        std::function<bool( BOARD_ITEM* )> aVisitor = nullptr,
                        int aClearance = 0 ) const
    {
        // keep track of BOARD_ITEMs that have already been found to collide (some items might
        // be built of COMPOUND/triangulated shapes and a single subshape collision means we have
        // a hit)
        std::unordered_set<BOARD_ITEM*> collidingCompounds;
 
        // keep track of results of client filter so we don't ask more than once for compound
        // shapes
        std::unordered_map<BOARD_ITEM*, bool> filterResults;
 
        BOX2I box = aRefItem->GetBoundingBox();
        box.Inflate( aClearance );
 
        int min[2] = { box.GetX(),     box.GetY() };
        int max[2] = { box.GetRight(), box.GetBottom() };
 
        std::shared_ptr<SHAPE> refShape = aRefItem->GetEffectiveShape( aRefLayer );
 
        int count = 0;
 
        auto visit =
                [&]( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    if( aItem->parent == aRefItem )
                        return true;
 
                    if( collidingCompounds.find( aItem->parent ) != collidingCompounds.end() )
                        return true;
 
                    bool filtered;
                    auto it = filterResults.find( aItem->parent );
 
                    if( it == filterResults.end() )
                    {
                        filtered = aFilter && !aFilter( aItem->parent );
                        filterResults[ aItem->parent ] = filtered;
                    }
                    else
                    {
                        filtered = it->second;
                    }
 
                    if( filtered )
                        return true;
 
                    wxCHECK( aItem->shape, false );
 
                    if( refShape->Collide( aItem->shape, aClearance ) )
                    {
                        collidingCompounds.insert( aItem->parent );
                        count++;
 
                        if( aVisitor )
                            return aVisitor( aItem->parent );
                    }
 
                    return true;
                };
 
        if( auto it = m_tree.find( aTargetLayer ); it != m_tree.end() )
            it->second.Search( min, max, visit );
 
        return count;
    }

    int QueryCollidingPreparedCopper(
            BOARD_ITEM* aRefItem, const std::shared_ptr<SHAPE>& aRefShape,
            PCB_LAYER_ID aTargetLayer, std::function<bool( BOARD_ITEM* )> aFilter,
            std::function<bool( BOARD_ITEM*, const std::shared_ptr<SHAPE>& )> aVisitor,
            int aClearance = 0, bool aUsePaddingCredit = false ) const
    {
        // PAD::GetEffectiveShape() returns null when a layer has no cached shape
        wxCHECK( aRefShape, 0 );
 
        std::unordered_set<BOARD_ITEM*>       collidingCompounds;
        std::unordered_map<BOARD_ITEM*, bool> filterResults;
        BOX2I                                 box = aRefItem->GetBoundingBox();
        int                                   inflation = aClearance;
 
        if( aUsePaddingCredit && aClearance >= 0 )
        {
            // Checked before the box grows, because the credit can leave inflation at 0.  A
            // reference whose bounds do not contain its own shape would shrink the query past a
            // real candidate and silently drop a clearance violation, so it pays full inflation
            // instead of getting a wrong answer in a release build
            bool contained = box.Contains( aRefShape->BBox() );
 
            wxASSERT_MSG( contained, wxT( "Padding credit needs the item bbox to contain its own shape" ) );
 
            auto paddingIt = m_minPadding.find( aTargetLayer );
 
            if( contained && paddingIt != m_minPadding.end() && paddingIt->second >= 0 )
                inflation = std::max( 0, aClearance - paddingIt->second );
        }
 
        box.Inflate( inflation );
 
        int min[2] = { box.GetX(), box.GetY() };
        int max[2] = { box.GetRight(), box.GetBottom() };
        int count = 0;
 
        auto visit =
                [&]( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    if( aItem->parent == aRefItem
                            || collidingCompounds.find( aItem->parent ) != collidingCompounds.end() )
                    {
                        return true;
                    }
 
                    auto [filterIt, inserted] = filterResults.emplace( aItem->parent, false );
 
                    if( inserted )
                        filterIt->second = aFilter && !aFilter( aItem->parent );
 
                    if( filterIt->second )
                        return true;
 
                    wxCHECK( aItem->shape, false );
 
                    if( aRefShape->Collide( aItem->shape, aClearance ) )
                    {
                        collidingCompounds.insert( aItem->parent );
                        count++;
 
                        if( aVisitor )
                            return aVisitor( aItem->parent, aItem->parentShape );
                    }
 
                    return true;
                };
 
        if( auto it = m_tree.find( aTargetLayer ); it != m_tree.end() )
            it->second.Search( min, max, visit );
 
        return count;
    }

    bool QueryColliding( const BOX2I& aBox, SHAPE* aRefShape, PCB_LAYER_ID aLayer, int aClearance,
                         int* aActual, VECTOR2I* aPos ) const
    {
        BOX2I bbox = aBox;
        bbox.Inflate( aClearance );
 
        int min[2] = { bbox.GetX(), bbox.GetY() };
        int max[2] = { bbox.GetRight(), bbox.GetBottom() };
 
        bool     collision = false;
        int      actual = INT_MAX;
        VECTOR2I pos;
 
        auto visit =
                [&]( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    int      curActual;
                    VECTOR2I curPos;
 
                    if( aRefShape->Collide( aItem->shape, aClearance, &curActual, &curPos ) )
                    {
                        collision = true;
 
                        if( curActual < actual )
                        {
                            actual = curActual;
                            pos = curPos;
                        }
 
                        // Stop looking after we have a true collision
                        if( actual <= 0 )
                            return false;
                    }
 
                    return true;
                };
 
        if( auto it = m_tree.find( aLayer ); it != m_tree.end() )
            it->second.Search( min, max, visit );
 
        if( collision )
        {
            if( aActual )
                *aActual = std::max( 0, actual );
 
            if( aPos )
                *aPos = pos;
 
            return true;
        }
 
        return false;
    }

    bool QueryColliding( const BOX2I& aBox, SHAPE* aRefShape, PCB_LAYER_ID aLayer ) const
    {
        SHAPE_POLY_SET* poly = dynamic_cast<SHAPE_POLY_SET*>( aRefShape );
 
        int  min[2] = { aBox.GetX(), aBox.GetY() };
        int  max[2] = { aBox.GetRight(), aBox.GetBottom() };
        bool collision = false;
 
        // Special case the polygon case.  Otherwise we'll call its Collide() method which will
        // triangulate it as well and then do triangle/triangle collisions.  This ends up being
        // *much* slower than 3 segment Collide()s and a PointInside().
        auto polyVisitor =
                [&]( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    const SHAPE* shape = aItem->shape;
 
                    // There are certain degenerate cases that result in empty zone fills, which
                    // will be represented in the rtree with only a root (and no triangles).
                    // https://gitlab.com/kicad/code/kicad/-/issues/18600
                    if( shape->Type() != SH_POLY_SET_TRIANGLE )
                        return true;
 
                    auto tri = static_cast<const SHAPE_POLY_SET::TRIANGULATED_POLYGON::TRI*>( shape );
 
                    const SHAPE_LINE_CHAIN& outline = poly->Outline( 0 );
 
                    for( int ii = 0; ii < (int) tri->GetSegmentCount(); ++ii )
                    {
                        if( outline.Collide( tri->GetSegment( ii ) ) )
                        {
                            collision = true;
                            return false;
                        }
                    }
 
                    // Also must check for poly being completely inside the triangle
                    if( tri->PointInside( outline.CPoint( 0 ) ) )
                    {
                        collision = true;
                        return false;
                    }
 
                    return true;
                };
 
        auto visitor =
                [&]( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    if( aRefShape->Collide( aItem->shape, 0 ) )
                    {
                        collision = true;
                        return false;
                    }
 
                    return true;
                };
 
        auto it = m_tree.find( aLayer );
 
        if( it == m_tree.end() )
            return false;
 
        if( poly && poly->OutlineCount() == 1 && poly->HoleCount( 0 ) == 0 )
            it->second.Search( min, max, polyVisitor );
        else
            it->second.Search( min, max, visitor );
 
        return collision;
    }

    std::unordered_set<BOARD_ITEM*> GetObjectsAt( const VECTOR2I& aPt, PCB_LAYER_ID aLayer,
                                                  int aClearance = 0 )
    {
        std::unordered_set<BOARD_ITEM*> retval;
        int min[2] = { aPt.x - aClearance, aPt.y - aClearance };
        int max[2] = { aPt.x + aClearance, aPt.y + aClearance };
 
        auto visitor =
                [&]( ITEM_WITH_SHAPE* aItem ) -> bool
                {
                    retval.insert( aItem->parent );
                    return true;
                };
 
        auto it = m_tree.find( aLayer );
 
        if( it != m_tree.end() )
            it->second.Search( min, max, visitor );
 
        return retval;
    }
 
    typedef std::pair<PCB_LAYER_ID, PCB_LAYER_ID> LAYER_PAIR;
 
    struct PAIR_INFO
    {
        PAIR_INFO( LAYER_PAIR aPair, ITEM_WITH_SHAPE* aRef, ITEM_WITH_SHAPE* aTest ) :
            layerPair( aPair ),
            refItem( aRef ),
            testItem( aTest )
        { };
 
        LAYER_PAIR       layerPair;
        ITEM_WITH_SHAPE* refItem;
        ITEM_WITH_SHAPE* testItem;
    };
 
    int QueryCollidingPairs( DRC_RTREE* aRefTree, std::vector<LAYER_PAIR> aLayerPairs,
                             std::function<bool( const LAYER_PAIR&, ITEM_WITH_SHAPE*,
                                                 ITEM_WITH_SHAPE*, bool* aCollision )> aVisitor,
                             int aMaxClearance,
                             std::function<bool(int, int )> aProgressReporter ) const
    {
        std::vector<PAIR_INFO> pairsToVisit;
 
        for( LAYER_PAIR& layerPair : aLayerPairs )
        {
            const PCB_LAYER_ID refLayer = layerPair.first;
            const PCB_LAYER_ID targetLayer = layerPair.second;
 
            for( ITEM_WITH_SHAPE* refItem : aRefTree->OnLayer( refLayer ) )
            {
                BOX2I box = refItem->shape->BBox();
                box.Inflate( aMaxClearance );
 
                int min[2] = { box.GetX(),     box.GetY() };
                int max[2] = { box.GetRight(), box.GetBottom() };
 
                auto visit =
                        [&]( ITEM_WITH_SHAPE* aItemToTest ) -> bool
                        {
                            // don't collide items against themselves
                            if( aItemToTest->parent == refItem->parent )
                                return true;
 
                            pairsToVisit.emplace_back( layerPair, refItem, aItemToTest );
                            return true;
                        };
 
                auto it = m_tree.find( targetLayer );
 
                if( it != m_tree.end() )
                    it->second.Search( min, max, visit );
            };
        }
 
        // keep track of BOARD_ITEMs pairs that have been already found to collide (some items
        // might be build of COMPOUND/triangulated shapes and a single subshape collision
        // means we have a hit)
        std::unordered_map<PTR_PTR_CACHE_KEY, int> collidingCompounds;
 
        int progress = 0;
        int count = pairsToVisit.size();
 
        for( const PAIR_INFO& pair : pairsToVisit )
        {
            if( !aProgressReporter( progress++, count ) )
                break;
 
            BOARD_ITEM* a = pair.refItem->parent;
            BOARD_ITEM* b = pair.testItem->parent;
 
            // 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 );
 
            // don't report multiple collisions for compound or triangulated shapes
            if( collidingCompounds.count( { a, b } ) )
                continue;
 
            bool collisionDetected = false;
 
            if( !aVisitor( pair.layerPair, pair.refItem, pair.testItem, &collisionDetected ) )
                break;
 
            if( collisionDetected )
                collidingCompounds[ { a, b } ] = 1;
        }
 
        return 0;
    }

    size_t size() const
    {
        return m_count;
    }
 
    bool empty() const
    {
        return m_count == 0;
    }

    struct DRC_LAYER
    {
        DRC_LAYER() = default;
 
        DRC_LAYER( const drc_rtree& aTree )
        {
            for( ITEM_WITH_SHAPE* item : aTree )
                m_items.push_back( item );
        }
 
        DRC_LAYER( const drc_rtree& aTree, const BOX2I& aRect )
        {
            int min[2] = { aRect.GetX(), aRect.GetY() };
            int max[2] = { aRect.GetRight(), aRect.GetBottom() };
 
            auto collector = [this]( ITEM_WITH_SHAPE* aItem ) -> bool
            {
                m_items.push_back( aItem );
                return true;
            };
 
            aTree.Search( min, max, collector );
        }
 
        std::vector<ITEM_WITH_SHAPE*> m_items;
 
        std::vector<ITEM_WITH_SHAPE*>::iterator begin() { return m_items.begin(); }
        std::vector<ITEM_WITH_SHAPE*>::iterator end() { return m_items.end(); }
    };
 
    DRC_LAYER OnLayer( PCB_LAYER_ID aLayer ) const
    {
        auto it = m_tree.find( aLayer );
        return it == m_tree.end() ? DRC_LAYER() : DRC_LAYER( it->second );
    }
 
    DRC_LAYER Overlapping( PCB_LAYER_ID aLayer, const VECTOR2I& aPoint, int aAccuracy = 0 ) const
    {
        BOX2I rect( aPoint, VECTOR2I( 0, 0 ) );
        rect.Inflate( aAccuracy );
        auto it = m_tree.find( aLayer );
        return it == m_tree.end() ? DRC_LAYER() : DRC_LAYER( it->second, rect );
    }
 
    DRC_LAYER Overlapping( PCB_LAYER_ID aLayer, const BOX2I& aRect ) const
    {
        auto it = m_tree.find( aLayer );
        return it == m_tree.end() ? DRC_LAYER() : DRC_LAYER( it->second, aRect );
    }
 
 
private:
    void recordPadding( PCB_LAYER_ID aLayer, int aPadding )
    {
        auto [it, inserted] = m_minPadding.emplace( aLayer, aPadding );
 
        if( !inserted )
            it->second = std::min( it->second, aPadding );
    }
 
    std::map<int, drc_rtree>         m_tree;
    std::map<int, drc_rtree_builder> m_builders;
    std::map<int, int>               m_minPadding;
    std::vector<ITEM_WITH_SHAPE*>    m_owned;
    size_t                           m_count = 0;
};
 
 
#endif /* DRC_RTREE_H_ */