constraint_builder.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 CONSTRAINT_BUILDER_H_
#define CONSTRAINT_BUILDER_H_
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <unordered_set>
#include <vector>
 
#include <math/vector2d.h>
#include <geometry/eda_angle.h>
#include <layer_ids.h>
 
#include <constraints/pcb_constraint.h>
 
class BOARD;
class BOARD_ITEM;
class PCB_DIMENSION_BASE;
class PCB_SHAPE;
class SEG;
 

EDA_ANGLE MeasureCornerAngle( const SEG& aA, const SEG& aB );
 

struct CONSTRAINT_ANCHOR_POINT
{
    CONSTRAINT_ANCHOR anchor;
    VECTOR2I          pos;
    int               index = -1;   
};
 

bool ConstraintPolygonIsModelable( const PCB_SHAPE* aShape );
 

std::vector<CONSTRAINT_ANCHOR_POINT> ConstraintShapeAnchors( const PCB_SHAPE* aShape );
 

std::optional<CONSTRAINT_ANCHOR_POINT> ConstraintShapeVertex( const PCB_SHAPE* aShape, int aIndex );
 

std::vector<PCB_SHAPE*> CollectConstraintShapes( const BOARD* aBoard, PCB_LAYER_ID aLayer = UNDEFINED_LAYER );
 

std::vector<BOARD_ITEM*> CollectConstrainableItems( const BOARD* aBoard, PCB_LAYER_ID aLayer = UNDEFINED_LAYER );
 

std::optional<CONSTRAINT_MEMBER> NearestAnchorAmong( const std::vector<PCB_SHAPE*>& aShapes,
                                                     const VECTOR2I& aPos, double aMaxDist );
 

std::unique_ptr<PCB_CONSTRAINT> BuildConstraintFromItems( BOARD_ITEM* aParent,
                                                          PCB_CONSTRAINT_TYPE aType,
                                                          const std::vector<BOARD_ITEM*>& aItems );
 

wxString ConstraintSelectionHint( PCB_CONSTRAINT_TYPE aType );
 

std::optional<CONSTRAINT_MEMBER> NearestConstraintAnchor( const BOARD* aBoard, const VECTOR2I& aPos, double aMaxDist,
                                                          const std::vector<CONSTRAINT_MEMBER>& aExclude = {},
                                                          PCB_LAYER_ID aLayer = UNDEFINED_LAYER );
 

BOARD_ITEM* ResolveConstrainableItem( const BOARD* aBoard, const KIID& aId );
 

bool IsConstrainableItem( const BOARD_ITEM* aItem );
 

std::optional<KIID> NearestOutlineShape( const BOARD* aBoard, const VECTOR2I& aPos, double aMaxDist, bool aAllowCircle,
                                         PCB_LAYER_ID aLayer = UNDEFINED_LAYER );
 

struct ENDPOINT_BINDING
{
    CONSTRAINT_ANCHOR sourceAnchor;
    CONSTRAINT_MEMBER target;
};
 

std::vector<ENDPOINT_BINDING> SelectEndpointBindings( const BOARD* aBoard, const KIID& aItem, const VECTOR2I& aStart,
                                                      const std::optional<VECTOR2I>& aEnd, double aMaxDist,
                                                      PCB_LAYER_ID aLayer = UNDEFINED_LAYER );
 

struct AUTO_CONSTRAINT
{
    std::unique_ptr<PCB_CONSTRAINT> constraint;
    bool                            needsSolve = false;
};
 

std::vector<AUTO_CONSTRAINT> SelectShapeAutoConstraints( const BOARD* aBoard, const PCB_SHAPE* aShape,
                                                         BOARD_ITEM* aParent, bool aAxisConstraint );
 

bool ConstraintIsDuplicateOnBoard( const BOARD* aBoard, const PCB_CONSTRAINT* aConstraint );
 

std::vector<CONSTRAINT_ANCHOR_POINT> ConstraintItemAnchors( const BOARD_ITEM* aItem );
 

std::optional<VECTOR2I> ConstraintAnchorPosition( const BOARD* aBoard, const CONSTRAINT_MEMBER& aMember );
 

double InitialConstraintValue( PCB_CONSTRAINT_TYPE aType, double aMeasured,
                               const std::map<PCB_CONSTRAINT_TYPE, double>& aRemembered );
 

std::optional<KIID> NearestConstrainedShape( const BOARD* aBoard, const std::vector<KIID>& aCandidates,
                                             const VECTOR2I& aPos, int aMaxDist );
 

std::unordered_set<KIID> CollectMemberCandidateIds( const BOARD* aBoard );
 

std::vector<KIID> ConstrainedShapeIds( const BOARD* aBoard );
 

std::optional<KIID> SelectRadialDimensionTarget( const BOARD* aBoard, const KIID& aDimension, const VECTOR2I& aCenter,
                                                 const VECTOR2I& aRim, double aMaxDist );
 

bool DimensionEndpointsBound( const BOARD* aBoard, const PCB_DIMENSION_BASE* aDimension );
 

enum class DIM_VALUE_MODE : int
{
    DRIVEN,
    DRIVING,
    ARBITRARY
};
 

bool DimensionHasValueMode( const PCB_DIMENSION_BASE* aDimension );
 

PCB_CONSTRAINT* FindDimensionLengthConstraint( const BOARD* aBoard, const PCB_DIMENSION_BASE* aDimension );
 

bool DimensionCanDrive( const BOARD* aBoard, const PCB_DIMENSION_BASE* aDimension );
 

DIM_VALUE_MODE DimensionValueMode( const BOARD* aBoard, const PCB_DIMENSION_BASE* aDimension );
 

PCB_CONSTRAINT* SetDimensionValueMode( BOARD* aBoard, PCB_DIMENSION_BASE* aDimension, DIM_VALUE_MODE aMode,
                                       std::optional<int>                        aDrivingLengthIU,
                                       const std::optional<wxString>&            aOverrideText,
                                       const std::function<void( BOARD_ITEM* )>& aBeforeModify,
                                       const std::function<void( BOARD_ITEM* )>& aStageAdd,
                                       const std::function<void( BOARD_ITEM* )>& aBeforeRemove );
 

void RemapPolygonVertexMembers( BOARD* aBoard, const KIID& aPoly, int aChangedIndex, int aDelta,
                                const std::function<void( BOARD_ITEM* )>& aBeforeModify,
                                const std::function<void( BOARD_ITEM* )>& aBeforeRemove );
 
#endif // CONSTRAINT_BUILDER_H_