| 
| def  | __init__ (self, *args) | 
|   | 
| def  | __eq__ (self, aSeg) | 
|   | 
| def  | __ne__ (self, aSeg) | 
|   | 
| def  | LineProject (self, aP) | 
|   | 
| def  | Side (self, aP) | 
|   | 
| def  | LineDistance (self, aP, aDetermineSide=False) | 
|   | 
| def  | Angle (self, aOther) | 
|   | 
| def  | NearestPoint (self, *args) | 
|   | 
| def  | NearestPoints (self, aSeg, aPtA, aPtB, aDistSq) | 
|   | 
| def  | ReflectPoint (self, aP) | 
|   | 
| def  | Intersect (self, aSeg, aIgnoreEndpoints=False, aLines=False) | 
|   | 
| def  | Intersects (self, aSeg) | 
|   | 
| def  | IntersectLines (self, aSeg) | 
|   | 
| def  | PerpendicularSeg (self, aP) | 
|   | 
| def  | ParallelSeg (self, aP) | 
|   | 
| def  | Collide (self, aSeg, aClearance, aActual=None) | 
|   | 
| def  | SquaredDistance (self, *args) | 
|   | 
| def  | Distance (self, *args) | 
|   | 
| def  | CanonicalCoefs (self, qA, qB, qC) | 
|   | 
| def  | Collinear (self, aSeg) | 
|   | 
| def  | ApproxCollinear (self, aSeg, aDistanceThreshold=1) | 
|   | 
| def  | ApproxParallel (self, aSeg, aDistanceThreshold=1) | 
|   | 
| def  | ApproxPerpendicular (self, aSeg) | 
|   | 
| def  | Overlaps (self, aSeg) | 
|   | 
| def  | Length (self) | 
|   | 
| def  | SquaredLength (self) | 
|   | 
| def  | TCoef (self, aP) | 
|   | 
| def  | Index (self) | 
|   | 
| def  | Contains (self, *args) | 
|   | 
| def  | Reverse (self) | 
|   | 
| def  | Reversed (self) | 
|   | 
| def  | Center (self) | 
|   | 
| def  | __lt__ (self, aSeg) | 
|   | 
 | 
|   | thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") | 
|   | 
|   | A = property(_pcbnew.SEG_A_get, _pcbnew.SEG_A_set, doc=) | 
|   | 
|   | B = property(_pcbnew.SEG_B_get, _pcbnew.SEG_B_set, doc=) | 
|   | 
Proxy of C++ SEG class.
 
Definition at line 5866 of file pcbnew.py.
 
◆ __init__()
      
        
          | def pcbnew.SEG.__init__  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
          *  | 
          args  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
    __init__(SEG self) -> SEG
    __init__(SEG self, int aX1, int aY1, int aX2, int aY2) -> SEG
    __init__(SEG self, VECTOR2I aA, VECTOR2I aB) -> SEG
    __init__(SEG self, VECTOR2I aA, VECTOR2I aB, int aIndex) -> SEG
    __init__(SEG self, SEG aSeg) -> SEG 
Definition at line 5874 of file pcbnew.py.
 
 
◆ __eq__()
      
        
          | def pcbnew.SEG.__eq__  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
__eq__(SEG self, SEG aSeg) -> bool
 
Definition at line 5884 of file pcbnew.py.
 
 
◆ __lt__()
      
        
          | def pcbnew.SEG.__lt__  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
__lt__(SEG self, SEG aSeg) -> bool
 
Definition at line 6025 of file pcbnew.py.
 
 
◆ __ne__()
      
        
          | def pcbnew.SEG.__ne__  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
__ne__(SEG self, SEG aSeg) -> bool
 
Definition at line 5888 of file pcbnew.py.
 
 
◆ Angle()
      
        
          | def pcbnew.SEG.Angle  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aOther  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Angle(SEG self, SEG aOther) -> EDA_ANGLE
 
Definition at line 5909 of file pcbnew.py.
 
 
◆ ApproxCollinear()
      
        
          | def pcbnew.SEG.ApproxCollinear  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg,  | 
        
        
           | 
           | 
            | 
          aDistanceThreshold = 1  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
ApproxCollinear(SEG self, SEG aSeg, int aDistanceThreshold=1) -> bool
 
Definition at line 5974 of file pcbnew.py.
 
 
◆ ApproxParallel()
      
        
          | def pcbnew.SEG.ApproxParallel  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg,  | 
        
        
           | 
           | 
            | 
          aDistanceThreshold = 1  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
ApproxParallel(SEG self, SEG aSeg, int aDistanceThreshold=1) -> bool
 
Definition at line 5978 of file pcbnew.py.
 
 
◆ ApproxPerpendicular()
      
        
          | def pcbnew.SEG.ApproxPerpendicular  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
ApproxPerpendicular(SEG self, SEG aSeg) -> bool
 
Definition at line 5982 of file pcbnew.py.
 
 
◆ CanonicalCoefs()
      
        
          | def pcbnew.SEG.CanonicalCoefs  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          qA,  | 
        
        
           | 
           | 
            | 
          qB,  | 
        
        
           | 
           | 
            | 
          qC  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
CanonicalCoefs(SEG self, SEG::ecoord & qA, SEG::ecoord & qB, SEG::ecoord & qC)
 
Definition at line 5966 of file pcbnew.py.
 
 
◆ Center()
      
        
          | def pcbnew.SEG.Center  | 
          ( | 
            | 
          self | ) | 
           | 
        
      
 
Center(SEG self) -> VECTOR2I
 
Definition at line 6021 of file pcbnew.py.
 
 
◆ Collide()
      
        
          | def pcbnew.SEG.Collide  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg,  | 
        
        
           | 
           | 
            | 
          aClearance,  | 
        
        
           | 
           | 
            | 
          aActual = None  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Collide(SEG self, SEG aSeg, int aClearance, int * aActual=None) -> bool
 
Definition at line 5948 of file pcbnew.py.
 
 
◆ Collinear()
      
        
          | def pcbnew.SEG.Collinear  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Collinear(SEG self, SEG aSeg) -> bool
 
Definition at line 5970 of file pcbnew.py.
 
 
◆ Contains()
      
        
          | def pcbnew.SEG.Contains  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
          *  | 
          args  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
    Contains(SEG self, SEG aSeg) -> bool
    Contains(SEG self, VECTOR2I aP) -> bool 
Definition at line 6006 of file pcbnew.py.
 
 
◆ Distance()
      
        
          | def pcbnew.SEG.Distance  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
          *  | 
          args  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
    Distance(SEG self, SEG aSeg) -> int
    Distance(SEG self, VECTOR2I aP) -> int 
Definition at line 5959 of file pcbnew.py.
 
 
◆ Index()
      
        
          | def pcbnew.SEG.Index  | 
          ( | 
            | 
          self | ) | 
           | 
        
      
 
Index(SEG self) -> int
 
Definition at line 6002 of file pcbnew.py.
 
 
◆ Intersect()
      
        
          | def pcbnew.SEG.Intersect  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg,  | 
        
        
           | 
           | 
            | 
          aIgnoreEndpoints = False,  | 
        
        
           | 
           | 
            | 
          aLines = False  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Intersect(SEG self, SEG aSeg, bool aIgnoreEndpoints=False, bool aLines=False) -> OPT_VECTOR2I
 
Definition at line 5928 of file pcbnew.py.
 
 
◆ IntersectLines()
      
        
          | def pcbnew.SEG.IntersectLines  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
IntersectLines(SEG self, SEG aSeg) -> OPT_VECTOR2I
 
Definition at line 5936 of file pcbnew.py.
 
 
◆ Intersects()
      
        
          | def pcbnew.SEG.Intersects  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Intersects(SEG self, SEG aSeg) -> bool
 
Definition at line 5932 of file pcbnew.py.
 
 
◆ Length()
      
        
          | def pcbnew.SEG.Length  | 
          ( | 
            | 
          self | ) | 
           | 
        
      
 
Length(SEG self) -> int
 
Definition at line 5990 of file pcbnew.py.
 
 
◆ LineDistance()
      
        
          | def pcbnew.SEG.LineDistance  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP,  | 
        
        
           | 
           | 
            | 
          aDetermineSide = False  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
LineDistance(SEG self, VECTOR2I aP, bool aDetermineSide=False) -> int
 
Definition at line 5905 of file pcbnew.py.
 
 
◆ LineProject()
      
        
          | def pcbnew.SEG.LineProject  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
LineProject(SEG self, VECTOR2I aP) -> VECTOR2I
 
Definition at line 5897 of file pcbnew.py.
 
 
◆ NearestPoint()
      
        
          | def pcbnew.SEG.NearestPoint  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
          *  | 
          args  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
    NearestPoint(SEG self, VECTOR2I aP) -> VECTOR2I
    NearestPoint(SEG self, SEG aSeg) -> VECTOR2I 
Definition at line 5913 of file pcbnew.py.
 
 
◆ NearestPoints()
      
        
          | def pcbnew.SEG.NearestPoints  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg,  | 
        
        
           | 
           | 
            | 
          aPtA,  | 
        
        
           | 
           | 
            | 
          aPtB,  | 
        
        
           | 
           | 
            | 
          aDistSq  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
NearestPoints(SEG self, SEG aSeg, VECTOR2I aPtA, VECTOR2I aPtB, int64_t & aDistSq) -> bool
 
Definition at line 5920 of file pcbnew.py.
 
 
◆ Overlaps()
      
        
          | def pcbnew.SEG.Overlaps  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aSeg  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Overlaps(SEG self, SEG aSeg) -> bool
 
Definition at line 5986 of file pcbnew.py.
 
 
◆ ParallelSeg()
      
        
          | def pcbnew.SEG.ParallelSeg  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
ParallelSeg(SEG self, VECTOR2I aP) -> SEG
 
Definition at line 5944 of file pcbnew.py.
 
 
◆ PerpendicularSeg()
      
        
          | def pcbnew.SEG.PerpendicularSeg  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
PerpendicularSeg(SEG self, VECTOR2I aP) -> SEG
 
Definition at line 5940 of file pcbnew.py.
 
 
◆ ReflectPoint()
      
        
          | def pcbnew.SEG.ReflectPoint  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
ReflectPoint(SEG self, VECTOR2I aP) -> VECTOR2I
 
Definition at line 5924 of file pcbnew.py.
 
 
◆ Reverse()
      
        
          | def pcbnew.SEG.Reverse  | 
          ( | 
            | 
          self | ) | 
           | 
        
      
 
 
◆ Reversed()
      
        
          | def pcbnew.SEG.Reversed  | 
          ( | 
            | 
          self | ) | 
           | 
        
      
 
Reversed(SEG self) -> SEG
 
Definition at line 6017 of file pcbnew.py.
 
 
◆ Side()
      
        
          | def pcbnew.SEG.Side  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
Side(SEG self, VECTOR2I aP) -> int
 
Definition at line 5901 of file pcbnew.py.
 
 
◆ Square()
  
  
      
        
          | def pcbnew.SEG.Square  | 
          ( | 
            | 
          a | ) | 
           | 
         
       
   | 
  
static   | 
  
 
Square(int a) -> SEG::ecoord
 
Definition at line 5893 of file pcbnew.py.
 
 
◆ SquaredDistance()
      
        
          | def pcbnew.SEG.SquaredDistance  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
          *  | 
          args  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
    SquaredDistance(SEG self, SEG aSeg) -> SEG::ecoord
    SquaredDistance(SEG self, VECTOR2I aP) -> SEG::ecoord 
Definition at line 5952 of file pcbnew.py.
 
 
◆ SquaredLength()
      
        
          | def pcbnew.SEG.SquaredLength  | 
          ( | 
            | 
          self | ) | 
           | 
        
      
 
SquaredLength(SEG self) -> SEG::ecoord
 
Definition at line 5994 of file pcbnew.py.
 
 
◆ TCoef()
      
        
          | def pcbnew.SEG.TCoef  | 
          ( | 
            | 
          self,  | 
        
        
           | 
           | 
            | 
          aP  | 
        
        
           | 
          ) | 
           |  | 
        
      
 
TCoef(SEG self, VECTOR2I aP) -> SEG::ecoord
 
Definition at line 5998 of file pcbnew.py.
 
 
  
  
      
        
          | pcbnew.SEG.A = property(_pcbnew.SEG_A_get, _pcbnew.SEG_A_set, doc=) | 
         
       
   | 
  
static   | 
  
 
 
  
  
      
        
          | pcbnew.SEG.B = property(_pcbnew.SEG_B_get, _pcbnew.SEG_B_set, doc=) | 
         
       
   | 
  
static   | 
  
 
 
◆ thisown
  
  
      
        
          | pcbnew.SEG.thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") | 
         
       
   | 
  
static   | 
  
 
 
The documentation for this class was generated from the following file: