Connection.hpp

#ifndef GYM_PCB_CONNECTION_H
#define GYM_PCB_CONNECTION_H
 
#include "Py.hpp"
#include "Defs.hpp"
#include "Color.hpp"
#include "Pin.hpp"
 
class CloneEnv;
class Component;
class Net;
class Track;
class UniformGrid25;
class NavGrid;
 
class Connection
{
    constexpr static const bool EndpointsOnMaskedLayersOK = true;
public:
    Connection *clone(CloneEnv&) const;
    Connection(Net *, const Point_25 &source, Pin *sourcePin, const Point_25 &target, Pin *targetPin);
    Connection(const Connection&, const Point_25 &source, const Point_25 &target);
    ~Connection();
 
    void setId(int id) { mId = id; }
    int id() const { return mId; }
    std::string name() const;
    bool hasNet() const { return !!mNet; }
    Net *net() const { return mNet; }
 
    const Point_25& source() const { return mSource; }
    const Point_25& target() const { return mTarget; }
    Pin *sourcePin() const { return mSourcePin; }
    Pin *targetPin() const { return mTargetPin; }
    Pin *otherPin(const Pin *) const;
 
    Component *sourceComponent() const { return mSourcePin ? mSourcePin->getParent() : 0; }
    Component *targetComponent() const { return mTargetPin ? mTargetPin->getParent() : 0; }
 
    Vector_2 vector2() const { return target().xy() - source().xy(); }
    Segment_2 segment2() const { return Segment_2(source().xy(), target().xy()); }
 
    void detachSourcePin();
    void detachTargetPin();
 
    void forceEndpointsToGrid(const UniformGrid25&);
 
    bool hasTracks() const { return !mTracks.empty(); }
    uint numTracks() const { return mTracks.size(); }
    const std::vector<Track *>& getTracks() const { return mTracks; }
    Track& getTrack(uint i) const { return *mTracks.at(i); }
    Track *getTrackAt(const Point_25&) const;
    Track *newTrack(const Point_25 &start);
    Track *popTrack(uint index);
    void clearTracks();
 
    bool isRouted() const { return mIsRouted; }
    bool _isRouted() const;
    void setRouted(bool b) { mIsRouted = b; }
    bool checkRouted() { setRouted(_isRouted()); return isRouted(); }

    void forceRouted();
 
    bool isLocked() const { return mLocked; }
    void setLocked(bool b) { mLocked = b; }

    void setTrack(Track *);
    void setTrack(Track&&);
    void setTrack(const Track&);

    void appendTrack(Track *T);
    void appendTrack(const Track &T);
 
    void reverse(); 

    void makeDirectTrack45(Real minSquaredLen, uint viaLocation, float bendLocation);
    void makeDirectTrack(Real minSquaredLen, uint viaLocation);

    bool updateForRemovedLayers(uint removedZMin, uint removedZMax);

    std::vector<std::pair<Point_25, Point_25>> getRatsNest() const;
 
    bool arePinsOnNet(const Net *) const; 
 
    Real clearance() const { return mClearance; }
    Real defaultWidth() const { return mWidth; }
    Real defaultViaDiameter() const { return mViaDiameter; }
    Real defaultViaRadius() const { return mViaDiameter * 0.5; }
 
    void setClearance(Real c) { mClearance = c; }
    void setDefaultWidth(float w) { mWidth = w; }
    void setDefaultViaDiameter(Real d) { mViaDiameter = d; }
 
    bool canRouteOnLayer(uint n) const { return mLayerMask & (1 << n); }
    uint32_t getLayerMask() const { return mLayerMask; }
 
    void setLayerMask(uint32_t);
 
    void setParametersFrom(const Connection&);
 
    float referenceLen() const { return mReferenceLen; }
    void setReferenceLen(float v) { assert(mReferenceLen == 0.0f && v > 0.0f); mReferenceLen = v; }
 
    Bbox_2 tracksBbox() const;
    Bbox_2 bbox() const;
    Bbox_2 bboxAroundComps() const;
 
    Real squared_distance() const { return CGAL::squared_distance(mSource.xy(), mTarget.xy()); }
    Real distance() const { return std::sqrt(squared_distance()); }
    Real distance45() const { return geo::distance45(mSource.xy(), mTarget.xy()); }
 
    bool isOrderedXMajor() const; 
 
    uint numNecessaryVias() const; 
 
    template<class Container> static void sort_name(Container&);

    bool intersects(const Connection&) const;

    bool isRasterized_allOrNone() const;

    bool checkRasterization(const NavGrid&) const;
 
    void setColor(Color c) { mColor = c; } 
    Color getColor() const;
 
    std::string str() const;

    PyObject *getEndsPy() const;
    PyObject *getTracksPy(bool asNumpy) const;
    PyObject *getPy(uint depth, bool asNumpy) const; 
private:
    Point_25 mSource;
    Point_25 mTarget;
    Pin *mSourcePin;
    Pin *mTargetPin;
    Net *const mNet;
    std::vector<Track *> mTracks;
    Real mClearance;
    Real mWidth;
    Real mViaDiameter;
    uint32_t mLayerMask{0xffffffff};
    int mId{-1};
    bool mIsRouted{false};
    bool mLocked{false};
    float mReferenceLen{0.0f};
    Color mColor{Color::TRANSPARENT};
 
private:
    void mergeTrack(Track *);
    void deleteEmptyTracks();
    void updateEndpointForLayerMask(bool target);
};
 
inline void Connection::setParametersFrom(const Connection &X)
{
    setClearance(X.clearance());
    setDefaultWidth(X.defaultWidth());
    setDefaultViaDiameter(X.defaultViaDiameter());
    setLayerMask(X.getLayerMask());
}
inline Pin *Connection::otherPin(const Pin *P) const
{
    assert(mSourcePin == P || mTargetPin == P);
    return (mSourcePin == P) ? mTargetPin : mSourcePin;
}
 
inline Track *Connection::popTrack(uint index)
{
    setRouted(false);
    const auto T = mTracks.at(index);
    mTracks.erase(mTracks.begin() + index);
    return T;
}
 
template<class Container> void Connection::sort_name(Container &A)
{
    std::sort(A.begin(),
              A.end(),
              [](const Connection *const L, const Connection *const R) -> bool { return L->name() < R->name(); });
}
 
#endif // GYM_PCB_CONNECTION_H