board_constraint_adapter.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 BOARD_CONSTRAINT_ADAPTER_H_
#define BOARD_CONSTRAINT_ADAPTER_H_
 
#include <deque>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <vector>
 
#include <kiid.h>
#include <math/vector2d.h>
 
#include <constraints/pcb_constraint.h>
 
class BOARD;
class BOARD_ITEM;
class PCB_DIMENSION_BASE;
class PCB_DIM_ORTHOGONAL;
class PCB_SHAPE;
 
// planegcs is an Eigen-heavy implementation detail; keep its header out of this one (PIMPL).
namespace GCS
{
class System;
}
 

struct CONSTRAINT_DIAGNOSIS
{
    bool              solved = false;   
    int               freeDof = -1;     
    std::vector<KIID> conflicting;      
    std::vector<KIID> redundant;        
 
    bool IsWellConstrained() const { return solved && freeDof == 0; }
    bool IsUnderConstrained() const { return freeDof > 0; }
    bool IsOverConstrained() const { return !conflicting.empty(); }
};
 

enum class CONSTRAINT_STATE
{
    UNCONSTRAINED,       
    UNDER_CONSTRAINED,   
    WELL_CONSTRAINED,    
    OVER_CONSTRAINED,    
};
 

struct BOARD_CONSTRAINT_DIAGNOSTICS
{
    int                              totalFreeDof = 0;
    std::map<KIID, CONSTRAINT_STATE> shapeStates;
    std::vector<KIID>                conflicting;
    std::vector<KIID>                redundant;
    std::vector<KIID>                errored;   
};
 

class BOARD_CONSTRAINT_ADAPTER
{
public:
    BOARD_CONSTRAINT_ADAPTER();
    ~BOARD_CONSTRAINT_ADAPTER();
 
    BOARD_CONSTRAINT_ADAPTER( const BOARD_CONSTRAINT_ADAPTER& ) = delete;
    BOARD_CONSTRAINT_ADAPTER& operator=( const BOARD_CONSTRAINT_ADAPTER& ) = delete;

    bool Build( const std::vector<PCB_SHAPE*>& aShapes, const std::vector<PCB_CONSTRAINT*>& aConstraints,
                const std::set<KIID>* aFixedShapes = nullptr,
                const std::vector<PCB_DIMENSION_BASE*>& aDimensions = {} );

    const std::vector<KIID>& UnmappedConstraints() const { return m_unmapped; }

    bool Solve( const CONSTRAINT_MEMBER& aDragged, const VECTOR2I& aCursor, bool aStabilize = false,
                const std::set<KIID>& aEdited = {},
                const std::optional<std::pair<CONSTRAINT_MEMBER, VECTOR2I>>& aCoDragged = std::nullopt );

    bool Solve( bool aStabilize = false );

    bool SolveAfterResize( const KIID& aResizedShape );

    std::vector<PCB_SHAPE*> Apply( const std::function<void( BOARD_ITEM* )>& aBeforeWrite = {} );

    void ApplyReferenceValues( const std::function<void( BOARD_ITEM* )>& aBeforeWrite = {} );

    CONSTRAINT_DIAGNOSIS Diagnose();
 
private:
    enum class SHAPE_KIND
    {
        SEGMENT,
        BEZIER,      
        CIRCLE,
        ARC,
        ELLIPSE,
        ELLIPSE_ARC,
        POINT_PAIR,  
        RECT,        
        POLYGON      
    };

    struct SHAPE_VARS
    {
        PCB_SHAPE*          shape = nullptr;
        PCB_DIMENSION_BASE* dimension = nullptr;   
        SHAPE_KIND kind = SHAPE_KIND::SEGMENT;
        int        startX = -1;        
        int        endX = -1;          
        int        radius = -1;        
        int        focusX = -1;        
        int        arcStartX = -1;     
        int        arcEndX = -1;       
        int        startAngle = -1;    
        int        endAngle = -1;      
        int                 fixedLengthParam = -1; 

        int vertexCount = 0;

        bool startIsLeft = true;
        bool startIsTop = true;
    };

    struct ANCHOR_PARAMS
    {
        int x = -1;
        int y = -1;
 
        bool IsValid() const { return x >= 0 && y >= 0; }
    };

    int pushParam( double aValue );

    void recordReferenceValue( PCB_CONSTRAINT* aConstraint );

    void holdFreeSegmentLengths( int aTag, const std::set<KIID>& aShapes );

    void holdFreeArcRadii( int aTag, const std::set<KIID>& aShapes );

    void holdArcRadius( const SHAPE_VARS& aVars, int aTag );

    void softPinPoint( const ANCHOR_PARAMS& aPoint, int aTag, std::optional<double> aWeight = std::nullopt );

    void softPinPoint( int aPointX, int aTag, std::optional<double> aWeight = std::nullopt );

    void holdPolygonVertices( const std::set<KIID>& aShapes, int aTag );

    void pinDraggedShapeRest( const CONSTRAINT_MEMBER& aDragged, int aTag,
                              const CONSTRAINT_MEMBER* aCoDragged = nullptr );

    void pinUneditedShapes( const std::set<KIID>& aEdited, int aTag );

    bool solveSucceeded( int aSolveResult );

    ANCHOR_PARAMS anchorParams( const CONSTRAINT_MEMBER& aMember ) const;

    PCB_DIM_ORTHOGONAL* orthogonalDimensionForMembers( const std::vector<CONSTRAINT_MEMBER>& aMembers ) const;

    double normalizeX( int aIU ) const { return ( aIU - m_originX ) * m_invScale; }
    double normalizeY( int aIU ) const { return ( aIU - m_originY ) * m_invScale; }
    double denormalizeX( double aNorm ) const { return aNorm * m_scale + m_originX; }
    double denormalizeY( double aNorm ) const { return aNorm * m_scale + m_originY; }
 
    std::unique_ptr<GCS::System> m_gcs;
 
    // Pointer-stable backing store for every solver double (see class comment).
    std::deque<double> m_params;
 
    std::map<KIID, SHAPE_VARS>    m_shapeVars;
    std::map<int, KIID>           m_tagToConstraint;
    std::set<int>                 m_nonDrivingTags;   
    std::map<int, std::vector<KIID>> m_tagMembers;    
    std::vector<PCB_CONSTRAINT*>  m_referenceConstraints;   
    std::vector<KIID>             m_unmapped;   

    std::set<KIID>                m_angleConstrainedShapes;
 
    double m_originX = 0.0;    
    double m_originY = 0.0;    
    double m_scale = 1.0;      
    double m_invScale = 1.0;   
 
    int m_dragTargetX = -1;    
    int m_dragTargetY = -1;    
    int m_coDragTargetX = -1;  
    int m_coDragTargetY = -1;  
 
    // Hold tags reserved by Build() just past the mapped constraints' tags, so a hold can never
    // collide with (and clear) a real constraint on a large cluster.
    int m_lengthHoldTag = -1;
    int m_resizeRadiusTag = -1;
 
    bool m_built = false;
};
 

CONSTRAINT_DIAGNOSIS SolveCluster( BOARD* aBoard, const CONSTRAINT_MEMBER& aDragged, const VECTOR2I& aCursor,
                                   std::vector<PCB_SHAPE*>*                  aModified = nullptr,
                                   const std::function<void( BOARD_ITEM* )>& aBeforeModify = {},
                                   bool aIncludeDragged = false, bool aStabilize = false,
                                   const std::set<KIID>& aEdited = {},
                                   const std::optional<std::pair<CONSTRAINT_MEMBER, VECTOR2I>>& aCoDragged =
                                           std::nullopt );
 

CONSTRAINT_DIAGNOSIS ApplyConstraintImmediately(
        BOARD* aBoard, const PCB_CONSTRAINT* aConstraint,
        std::vector<PCB_SHAPE*>* aModified = nullptr,
        const std::function<void( BOARD_ITEM* )>& aBeforeModify = {} );
 

bool BoardHasConstraints( BOARD* aBoard );
 

bool ConstraintItemIsLocked( const BOARD_ITEM* aItem );
 

void ReSolveShapeClusters( BOARD* aBoard, const std::vector<PCB_SHAPE*>& aShapes,
                           std::vector<PCB_SHAPE*>*                  aModified = nullptr,
                           const std::function<void( BOARD_ITEM* )>& aBeforeModify = {} );
 

void ReSolveShapeClustersHoldingEdited( BOARD* aBoard, const std::vector<PCB_SHAPE*>& aEditedShapes,
                                        std::vector<PCB_SHAPE*>*                  aModified = nullptr,
                                        const std::function<void( BOARD_ITEM* )>& aBeforeModify = {} );
 

void ReSolveAfterShapeResize( BOARD* aBoard, PCB_SHAPE* aShape, std::vector<PCB_SHAPE*>* aModified = nullptr,
                              const std::function<void( BOARD_ITEM* )>& aBeforeModify = {} );
 

BOARD_CONSTRAINT_DIAGNOSTICS DiagnoseBoardConstraints( BOARD* aBoard );
 

struct CLUSTER_DIAGNOSIS
{
    CONSTRAINT_STATE  state = CONSTRAINT_STATE::WELL_CONSTRAINED;
    std::vector<KIID> shapeIds;          
    std::vector<KIID> dimensionIds;      
    int               freeDof = 0;       
    std::vector<KIID> conflicting;
    std::vector<KIID> redundant;
    std::vector<KIID> erroredUnmapped;   
};
 

class BOARD_CONSTRAINT_DIAGNOSER
{
public:
    BOARD_CONSTRAINT_DIAGNOSTICS Diagnose( BOARD* aBoard );

    void Clear();

    std::size_t SolveCount() const { return m_solveCount; }
 
private:
    struct CACHE_ENTRY
    {
        std::size_t       hash = 0;
        CLUSTER_DIAGNOSIS result;
    };
 
    // Keyed by the cluster sorted constraint-id set which is stable across a geometry or value
    // edit and changes only when a constraint is added to or removed from the cluster
    std::map<std::vector<KIID>, CACHE_ENTRY> m_cache;
    std::size_t                              m_solveCount = 0;
};
 
#endif // BOARD_CONSTRAINT_ADAPTER_H_