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 <vector>
 
#include <math/vector2d.h>
#include <geometry/eda_angle.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( BOARD* aBoard );
 

std::vector<BOARD_ITEM*> CollectConstrainableItems( BOARD* aBoard );
 

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 );
 

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

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

struct DIMENSION_ENDPOINT_BINDING
{
    CONSTRAINT_ANCHOR dimAnchor;
    CONSTRAINT_MEMBER target;
};
 

std::vector<DIMENSION_ENDPOINT_BINDING>
SelectDimensionEndpointBindings( BOARD* aBoard, const KIID& aDimension, const VECTOR2I& aStart,
                                 const std::optional<VECTOR2I>& aEnd, double aMaxDist );
 

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

std::optional<VECTOR2I> ConstraintAnchorPosition( 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 std::vector<PCB_SHAPE*>& aCandidates,
                                             const VECTOR2I& aPos, int aMaxDist );
 

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

bool DimensionEndpointsBound( 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( BOARD* aBoard, const PCB_DIMENSION_BASE* aDimension );
 

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

DIM_VALUE_MODE DimensionValueMode( 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_