tracks_cleaner.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.
 *
 * 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/>.
 */
 
#ifndef KICAD_TRACKS_CLEANER_H
#define KICAD_TRACKS_CLEANER_H
 
#include <mutex>
#include <board.h>
 
class BOARD_COMMIT;
class CLEANUP_ITEM;
class REPORTER;
class PCB_TRACK;
 
 
// Helper class used to clean tracks and vias
class TRACKS_CLEANER
{
public:
    TRACKS_CLEANER( BOARD* aPcb, BOARD_COMMIT& aCommit );

    void CleanupBoard( bool aDryRun, std::vector<std::shared_ptr<CLEANUP_ITEM> >* aItemsList,
                       bool aCleanVias, bool aRemoveMisConnected, bool aMergeSegments,
                       bool aDeleteUnconnected, bool aDeleteTracksinPad, bool aDeleteDanglingVias,
                       REPORTER* aReporter = nullptr );
 
    void SetFilter( const std::function<bool( BOARD_CONNECTED_ITEM* aItem )>& aFilter )
    {
        m_filter = aFilter;
    }
 
private:
    bool filterItem( BOARD_CONNECTED_ITEM* aItem );
 
    /*
     * Removes track segments which are connected to more than one net (short circuits).
     */
    void removeShortingTrackSegments();

    bool deleteDanglingTracks( bool aTrack, bool aVia );
 
    void deleteTracksInPads();

    void cleanup( bool aDeleteDuplicateVias, bool aDeleteNullSegments,
                  bool aDeleteDuplicateSegments, bool aMergeSegments );

    bool mergeCollinearSegments( PCB_TRACK* aSeg1, PCB_TRACK* aSeg2 );

    bool testMergeCollinearSegments( PCB_TRACK* aSeg1, PCB_TRACK* aSeg2, PCB_TRACK* aDummySeg = nullptr );

    bool testTrackEndpointIsNode( PCB_TRACK* aTrack, bool aTstStart, bool aTstEnd );
 
    void removeItems( std::set<BOARD_ITEM*>& aItems );
 
    const std::vector<BOARD_CONNECTED_ITEM*>& getConnectedItems( PCB_TRACK* aTrack );
 
private:
    BOARD*                                      m_brd;
    BOARD_COMMIT&                               m_commit;       // caller owns
    bool                                        m_dryRun;
    std::vector<std::shared_ptr<CLEANUP_ITEM>>* m_itemsList;    // caller owns
    REPORTER*                                   m_reporter;
 
    // Cache connections.  O(n^2) is awful, but it beats O(2n^3).
    std::map<PCB_TRACK*, std::vector<BOARD_CONNECTED_ITEM*>> m_connectedItemsCache;
 
    std::function<bool( BOARD_CONNECTED_ITEM* aItem )>       m_filter;
    std::mutex m_mutex;
};
 
 
#endif //KICAD_TRACKS_CLEANER_H