drc_creepage_engine.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.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#pragma once
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>
 
#include <math/box2.h>
#include <layer_ids.h>
#include <pcb_shape.h>
 
#include <drc/drc_creepage_utils.h>
 
class BOARD;

struct CREEPAGE_RESULT
{
    int                    m_netA = -1;
    int                    m_netB = -1;
    double                 m_distance = 0.0;
    double                 m_constraint = 0.0;
    bool                   m_violation = false;
    VECTOR2I               m_start;
    VECTOR2I               m_end;
    const BOARD_ITEM*      m_itemA = nullptr;
    const BOARD_ITEM*      m_itemB = nullptr;
    std::vector<PCB_SHAPE> m_path;
};
 

class CREEPAGE_ENGINE
{
public:
    explicit CREEPAGE_ENGINE( BOARD& aBoard );
 
    void SetMinGrooveWidth( int aWidth ) { m_minGrooveWidth = aWidth; }

    std::optional<CREEPAGE_RESULT> SolveNetPairWholeBoard( int aNetA, int aNetB, PCB_LAYER_ID aLayer,
                                                           double aConstraint );

    void BeginInteractive( PCB_LAYER_ID aLayer, const std::set<int>& aAffectedNets,
                           const std::set<const BOARD_ITEM*>& aMovingItems, int aMargin,
                           std::function<double( int, int )> aConstraintFn );

    std::vector<CREEPAGE_RESULT> Update( int aNearMargin = 0 );
 
    void EndInteractive();
 
    bool IsInteractive() const { return m_interactive; }
 
private:
    void populateBoardEdgeGraph( CREEPAGE_GRAPH& aGraph, SHAPE_POLY_SET& aOutline );

    void connectChildren( CREEPAGE_GRAPH& aGraph );

    std::optional<CREEPAGE_RESULT>
    extractResult( const std::vector<std::shared_ptr<GRAPH_CONNECTION>>& aPath, double aDistance,
                   int aNetA, int aNetB, double aConstraint, int aNearMargin );

    std::map<int, std::shared_ptr<GRAPH_NODE>> addNetsInRegion( const BOX2I& aRegion );

    void buildBoardEdgePrefix();

    bool movingItemsHaveNPTH() const;
 
private:
    BOARD&       m_board;
    int          m_minGrooveWidth = 0;
 
    bool         m_interactive = false;
    bool         m_dynamicEdges = false;
    PCB_LAYER_ID m_layer = UNDEFINED_LAYER;
    int          m_margin = 0;
 
    std::set<int>                     m_affectedNets;
    std::set<const BOARD_ITEM*>       m_movingItems;
    std::function<double( int, int )> m_constraintFn;
 
    // Bounding box of every non-affected net, cached once at drag start. Non-affected geometry is
    // static during a drag, so this avoids recomputing NETINFO_ITEM::GetBoundingBox (a full
    // connectivity sweep) for every net on every frame.
    std::map<int, BOX2I> m_staticNetBBoxes;
 
    std::unique_ptr<CREEPAGE_GRAPH> m_graph;
    std::unique_ptr<SHAPE_POLY_SET> m_outline;
 
    // The static board-edge sub-graph prefix: nodes [0, m_staticNodeCount) and connections
    // [0, m_staticConnCount) are pure board geometry, reused every frame.
    size_t m_staticNodeCount = 0;
    size_t m_staticConnCount = 0;
};