Path.hpp

 
#ifndef GYM_PCB_PATH_H
#define GYM_PCB_PATH_H
 
#include "Py.hpp"
#include "Geometry.hpp"
#include <vector>
 
class Pin;
class Via;
 
class Path
{
public:
    const Point_25& getPoint(uint i) const { return mPoints.at(i); }
    const std::vector<Point_25>& getPoints() const { return mPoints; }
    void setPoint(uint i, const Point_25 &v) { mPoints.at(i) = v; }
 
    const Point_25& front() const { return mPoints.front(); }
    const Point_25& back() const { return mPoints.back(); }
    const Point_25& back(uint n) const { assert(mPoints.size() >= n); return mPoints[mPoints.size() - n]; }
    Point_25 pop_back();
 
    bool isPlanarAt(uint i) const;
    Segment_2 getSegmentAt(uint i) const;
 
    uint numPoints() const { return mPoints.size(); }
    bool empty() const { return mPoints.empty(); }
    uint numLayerChanges() const { return mNumLayerChanges; }

    Real length() const { return mLength; }
    Real RMSD() const { return mRMSD; }
    float winding() const { return mWinding; }
    float turning() const { return mTurning; } // sum of abs(angle)
 
    Bbox_2 bbox() const;
    Bbox_2 bbox(int z) const;
 
    void clear();
    void resizeTo1();
    void setPoints(const std::vector<Point_25>&, uint start, uint size);
    void _add(const Point_25 &v) { mPoints.push_back(v); }
    void add(const Point_25&);
    void extendTo(const Point_25&);
    void append(const Path&);
    void reverse();
    uint removeUnnecessaryPoints();

    void computeLength();
    void computeRMSD();
    void computeWinding();
 
    bool compare(const Path&) const;
 
    Real squared_distance(const Point_25&, Real dz = std::numeric_limits<Real>::infinity()) const;
    Real squared_distance(const Pin&) const;
    bool intersects(const Path&) const;
    bool violatesClearance(const Path&, Real clearance) const;
    bool violatesClearance(const Via&, Real clearance) const;
    uint countIntersections(const Path&) const;
 
    std::string str() const;
    PyObject *getIntegerPointsPy(Real scaleXY) const;
    PyObject *getPointsNumpy() const;
protected:
    std::vector<Point_25> mPoints;
    uint mNumLayerChanges{0};
    Real mLength{0.0f};
    Real mRMSD;
    float mWinding;
    float mTurning;
};
 
inline void Path::clear()
{
    mPoints.clear();
    mLength = 0.0f;
    mNumLayerChanges = 0;
}
inline void Path::resizeTo1()
{
    mPoints.resize(1);
    mLength = 0.0f;
    mNumLayerChanges = 0;
}
 
inline bool Path::isPlanarAt(uint i) const
{
    assert(i > 0 && i < mPoints.size());
    return mPoints[i].z() == mPoints[i-1].z();
}
inline Segment_2 Path::getSegmentAt(uint i) const
{
    assert(isPlanarAt(i));
    return Segment_2(mPoints[i-1].xy(), mPoints[i].xy());
}
 
inline Point_25 Path::pop_back()
{
    assert(!empty());
    const auto v = mPoints.back();
    mPoints.pop_back();
    return v;
}
 
#endif // GYM_PCB_PATH_H