NavGrid.hpp

#ifndef GYM_PCB_NAVGRID_H
#define GYM_PCB_NAVGRID_H
 
#include "NavPoint.hpp"
#include "Rasterizer.hpp"
//#include "Util/HugePageAllocator.hpp"


 
class PCBoard;
class Component;
class Pin;
class Path;
class Connection;

constexpr const bool CanSafelyEraseOverlappingSegments = false;

struct NavSpacings
{
    Real Clearance;
    Real TrackWidthHalf;
    Real ViaRadius;
    NavSpacings() { }
    NavSpacings(const Connection&);
    bool initialized() const { return !std::isnan(Clearance); }
    bool operator==(const NavSpacings &that) const { return Clearance == that.Clearance && TrackWidthHalf == that.TrackWidthHalf && ViaRadius == that.ViaRadius; }
    Real getExpansionForTracks(Real clearance) const;
    Real getExpansionForVias(Real clarance) const;
};
 
struct AStarCosts
{
    float MaskedLayer;
    float Via;
    float Violation;
    float WrongDirection;
    void reset();
    void setViolationCostInf() { Violation = std::numeric_limits<float>::infinity(); }
    void setXYBiasNone() { WrongDirection = 1.0f; }
    bool valid() const { return MaskedLayer >= 0.0f && Via >= 0.0f && Violation >= 0.0f && WrongDirection >= 0.0f; }
    void setPy(PyObject *);
};

class NavGrid : public UniformGrid25
{
public:
    NavGrid(PCBoard&);
    const PCBoard& getPCB() const { return mPCB; }
    PCBoard& getPCB() { return mPCB; }
 
    void build();
    void copyFrom(const NavGrid&);
 
    const std::vector<NavPoint>& getPoints() const { return mPoints; }
    std::vector<NavPoint>& getPoints() { return mPoints; }
    uint getNumPoints() const { return mPoints.size(); }
 
    const NavPoint& getPoint(uint i) const { return mPoints[i]; }
    const NavPoint& getPoint(uint x, uint y, uint z) const;
    const NavPoint *getPoint(const Point_2&, uint z) const;
    const NavPoint *getPoint(const Point_25 &v) const { return getPoint(v.xy(), v.z()); }
    NavPoint& getPoint(uint i) { return mPoints[i]; }
    NavPoint& getPoint(uint x, uint y, uint z);
    NavPoint& getPoint(const IPoint_3 &v) { return getPoint(v.x, v.y, v.z); }
    NavPoint *getPoint(const Point_2&, uint z);
    NavPoint *getPoint(const Point_25 &v) { return getPoint(v.xy(), v.z()); }
    int getDirectionStride(GridDirection d) const { assert(d.n() <= 9); return mDirectionStride[d.n()]; }
    uint32_t getAddressOffset(const NavPoint *nav) const;
    NavPoint *getPointFromAddressOffset(uint32_t);
 
    const NavSpacings& getSpacings() const { return mSpacings; }
    bool setSpacings(const NavSpacings&);
    void initSpacingsForAnyRoutedTrack();
 
    void resetKeepouts();
    void resetKeepoutsRRR();
    void rasterize(const Component&, const NavRasterizeParams&);
    void rasterize(const Pin&, const NavRasterizeParams&);
    void rasterizeCompound(const Pin&, const NavRasterizeParams&);
    void rasterize(const Connection&, const NavRasterizeParams&);
    void rasterizeLayoutAreaBorder(const NavRasterizeParams&);
    void rasterize(const Track&, const NavRasterizeParams&, uint rasterizeMask);
    void rasterize(const Path&, const NavRasterizeParams&);
 
    void getCosts(std::vector<float>&, uint index);
    void setCosts(uint index, float, const IBox_3&);
    void setCosts(uint index, const float *, const IBox_3&);
    void setCosts(uint index, const float *);
    AStarCosts& getAStarCosts() { return mAStarCosts; }
    bool findPathAStar(Connection&, const AStarCosts *);
    Real sumViolationArea(const Connection&);
 
    uint16_t nextRasterSeq();
    uint16_t nextSearchSeq();
    uint16_t getSearchSeq() const { return mSearchSeq; }
 
    std::string str(const IBox_3 * = 0) const;
    PyObject *getPy(const IBox_3&) const;
    PyObject *getPathCoordinatesNumpy(const Track&) const;
 
private:
    PCBoard &mPCB;
    std::vector<NavPoint> mPoints;
    NavSpacings mSpacings;
    // We use these to look up the addresses of neighbours in the grid because NavPoint doesn't have edge pointers (to save space).
    int mDirectionStride[10];
    AStarCosts mAStarCosts;
 
private:
    void initDirectionStrides();
    void initEdges(NavPoint&, const IPoint_3&);
    void rasterizeFootprints();
    void rasterizeClearanceAreas();
    void rasterize(const AShape *, uint Z0, uint Z1, const NavRasterizeParams&);
 
    uint16_t mSearchSeq{0};
    uint16_t mRasterSeq{0};
    void resetSearchSeq();
    void resetRasterSeq();
};
 
inline NavPoint& NavGrid::getPoint(uint x, uint y, uint z)
{
    return mPoints.at(LinearIndex(z,y,x));
}
inline const NavPoint& NavGrid::getPoint(uint x, uint y, uint z) const
{
    return mPoints.at(LinearIndex(z,y,x));
}
inline NavPoint *NavGrid::getPoint(const Point_2 &v, uint z)
{
    const uint x = XIndex(v.x(), 0.0);
    const uint y = YIndex(v.y(), 0.0);
    return inside(x,y,z) ? &getPoint(x, y, z) : 0;
}
inline const NavPoint *NavGrid::getPoint(const Point_2 &v, uint z) const
{
    const uint x = XIndex(v.x(), 0.0);
    const uint y = YIndex(v.y(), 0.0);
    return inside(x,y,z) ? &getPoint(x, y, z) : 0;
}
 
inline uint16_t NavGrid::nextSearchSeq()
{
    if (mSearchSeq == 0x7fff) // 0x8000 is used to indicate that a point is on A-star's open list
        resetSearchSeq();
    return ++mSearchSeq;
}
inline uint16_t NavGrid::nextRasterSeq()
{
    if (mRasterSeq == 0xffff)
        resetRasterSeq();
    return ++mRasterSeq;
}
 
inline Real NavSpacings::getExpansionForTracks(Real clearance) const
{
    return std::max(Clearance, clearance) + TrackWidthHalf;
}
inline Real NavSpacings::getExpansionForVias(Real clearance) const
{
    return std::max(Clearance, clearance) + ViaRadius;
}
 
inline NavPoint *NavPoint::getEdge(NavGrid &nav, GridDirection d) const
{
    char *_this = const_cast<char *>(reinterpret_cast<const char *>(this));
    if (!hasEdge(d))
        return 0;
    return reinterpret_cast<NavPoint *>(_this + nav.getDirectionStride(d));
}
 
inline uint32_t NavGrid::getAddressOffset(const NavPoint *nav) const
{
    const char *base = reinterpret_cast<const char *>(&mPoints[0]);
    const char *addr = reinterpret_cast<const char *>(nav);
    return addr - base;
}
inline NavPoint *NavGrid::getPointFromAddressOffset(uint32_t offset)
{
    char *base = reinterpret_cast<char *>(&mPoints[0]);
    return reinterpret_cast<NavPoint *>(base + offset);
}
 
#endif // GYM_PCB_NAVGRID_H