net_layout_junction.h

Go to the documentation of this file.

#pragma once
 
#include <QPoint>
#include <QPointF>
 
#include <QList>
#include <QHash>
#include <QColor>
#include <QRect>
#include "gui/graph_widget/layouters/net_layout_point.h"
 
// #define JUNCTION_DEBUG = 1
 
class QGraphicsEllipseItem;
class QGraphicsLineItem;
class QGraphicsScene;
 
const int DELTA = 20;
const int FIRST = 400;
const int GAP   = 200;
 
namespace hal {
 
    class LaneIndex
    {
        friend uint qHash(const LaneIndex& ri);
        int mIndex;
    public:
        enum HVIndex { Horizontal, Vertical };
 
        LaneIndex(HVIndex ihv, int ilane) : mIndex(ihv | (ilane << 1)) {;}
 
        operator int () const { return mIndex; }
 
        LaneIndex& operator++() { mIndex += 2; return *this; }
 
        LaneIndex& operator--() { mIndex -= 2; return *this; }
 
        HVIndex hvIndex() const { return (HVIndex) (mIndex & 1); }
 
        int laneIndex() const { return (mIndex >> 1); }
 
        bool isHorizontal() const { return hvIndex() == Horizontal; }
 
        bool isVertical() const { return hvIndex() == Vertical; }
 
        static LaneIndex horizontal(int ilane) { return LaneIndex(Horizontal,ilane); }
 
        static LaneIndex vertical(int ilane) { return LaneIndex(Vertical,ilane); }
    };
 
    class NetLayoutJunctionWire;
 
    class NetLayoutJunctionRange
    {
        u32 mNetId;
        int mFirst;
        int mLast;
    public:
        static const int MinInf = -32767;
        static const int MaxInf =  32767;
 
        NetLayoutJunctionRange(u32 netId_, int first, int last);
 
        bool conflict(const NetLayoutJunctionRange& other) const;
 
        bool contains(int pos) const { return mFirst <= pos && pos <= mLast; }
 
        bool innerPos(int pos) const { return mFirst < pos && pos < mLast; }
 
        bool canJoin(const NetLayoutJunctionRange& other) const;
 
        bool isEntry(int iTestMax) const;
 
        bool operator==(const NetLayoutJunctionRange& other) const;
 
        bool operator==(const NetLayoutJunctionWire& wire) const;
 
        u32 netId() const { return mNetId; }
 
        int first() const { return mFirst; }
 
        void setFirst(int fst) { mFirst = fst; }
 
        int last() const { return mLast; }
 
        void setLast(int lst)  { mLast  = lst; }
 
        int length() const { return mLast-mFirst; }
 
        int endPosition(int iGetLast) const;
 
        void expand(const NetLayoutJunctionRange& other);
 
        QString toString() const { return QString("<%1|%2..%3>").arg(mNetId).arg(mFirst).arg(mLast); }
 
        static NetLayoutJunctionRange entryRange(NetLayoutDirection dir, int ilane, u32 netId);
    };
 
    class NetLayoutJunctionWire
    {
    public:
        LaneIndex mIndex;
 
        NetLayoutJunctionRange mRange;
 
        NetLayoutJunctionWire(const NetLayoutJunctionRange& rng, const LaneIndex& li)
            : mIndex(li),  mRange(rng) {;}
 
        bool isEntry() const;
    };
 
    class NetLayoutJunctionEntries
    {
    public:
        QList<u32> mEntries[4];
 
        u32 id(NetLayoutDirection dir, int ilane) const { return mEntries[dir.index()].at(ilane); }
 
        QString toString() const;
 
        void dumpToFile(const QPoint& pnt) const;
 
        static QString gridPointName(const QPoint& p);
 
        bool isTrivial() const;
 
        static void resetFile();
    };
 
    class NetLayoutJunctionMultiPin
    {
    public:
        int mLane;
 
        QList<int> mConnector;
 
        NetLayoutJunctionMultiPin() : mLane(-1) {}
    };
 
 
    class NetLayoutJunctionNet
    {
        u32 mPattern;       // binary pattern
        int mLaneIndex[4];  // index: Left = 0, Right = 1, Up = 2, Down = 3    value: -1 = unused
        int mEntries;
        bool mPlaced;
    public:
        QList<NetLayoutJunctionWire> mWires;
        QList<QPoint> mKnots;
 
        NetLayoutJunctionNet();
        void addEntry(NetLayoutDirection dir, int laneInx);
        QString toString() const;
 
        bool hasPattern(u32 searchPattern) const;
        int laneIndex(NetLayoutDirection dir) const { return mLaneIndex[dir.index()]; }
        int numberEntries() const { return mEntries; }
        u32 pattern() const { return mPattern; }
        void setPattern(u32 pat) { mPattern = pat; }
        bool isPlaced() const { return mPlaced; }
        QList<NetLayoutJunctionWire> wireAtPos(int pos, LaneIndex::HVIndex hvi);
        void setPlaced() { mPlaced = true; }        
        void addWire(const NetLayoutJunctionWire& wire) { mWires.append(wire); }
        void replaceWire(const NetLayoutJunctionRange& rng, const NetLayoutJunctionWire& wire);
        QList<QPoint> junctionKnots() const { return mKnots; }
    };
 
     class NetLayoutJunctionOccupied : public QList<NetLayoutJunctionRange>
    {
    public:
        bool conflict(const NetLayoutJunctionRange& test) const;
        bool canJoin(u32 netId, int pos) const;
    };
 
    class NetLayoutJunctionOccupiedHash : public QHash<LaneIndex,NetLayoutJunctionOccupied>
    {
    public:
        class AddOrMerge
        {
        public:
            enum Type { Added, Merged, AlreadyExisting } mType;
            NetLayoutJunctionRange* mOldRange;
            NetLayoutJunctionRange* mNewRange;
            AddOrMerge() : mType(Added), mOldRange(nullptr), mNewRange(nullptr) {;}
            ~AddOrMerge()
            {
                if (mOldRange) delete mOldRange;
                if (mNewRange) delete mNewRange;
            }
        };
 
        AddOrMerge addOrMerge(const LaneIndex &ri, const NetLayoutJunctionRange& rng);
 
#ifdef JUNCTION_DEBUG
        QList<QPair<u32,NetLayoutJunctionWire>> mHistory;
#endif
    };
 
    class NetLayoutJunction
    {
    public:
        NetLayoutJunction(const NetLayoutJunctionEntries& entries);
        ~NetLayoutJunction() {;}
        QRect rect() const { return mRect; }
        NetLayoutJunctionNet netById(u32 id) const { return mNets.value(id); }
 
        enum ErrorType {StraightRouteError = -3, TRouteError = -2, CornerRouteError = -1, Ok = 0 };
        ErrorType lastError() const { return mError; }
 
#ifdef JUNCTION_DEBUG
        void toScene(QGraphicsScene* scene) const;
        void toSceneStep(QGraphicsScene* scene, int istep);
        int numberSteps() const { return mOccupied.mHistory.size(); }
#endif
    private:
        void routeT();
        void routeAllStraight(NetLayoutDirection dirFrom, NetLayoutDirection dirTo);
        void routeAllCorner(NetLayoutDirection dirHoriz, NetLayoutDirection dirVertic);
        void routeSingleStraight(u32 netId, int iMain, int iroadIn, int iroadOut);
        void routeSingleSwap(u32 netId, int iMain, int iroadIn, int iroadOut);
        void routeSingleCorner(u32 netId, NetLayoutDirection dirHoriz, NetLayoutDirection dirVertic);
 
        void routeAllMultiPin(NetLayoutDirection leftOrRight);
 
        void routeSingleMultiPin(u32 netId, NetLayoutDirection leftOrRight, const NetLayoutJunctionMultiPin &nmpin);
        void findJunctions();
        void calculateRect();
        bool conflict(const LaneIndex& ri, const NetLayoutJunctionRange& testRng) const;
        void place(const LaneIndex& ri, const NetLayoutJunctionRange& range);
        bool canJoin(const LaneIndex& ri, u32 netId, int pos) const;
 
        QRect mRect;
        NetLayoutJunctionEntries mEntries;
        QHash<u32,NetLayoutJunctionNet> mNets;
        NetLayoutJunctionOccupiedHash mOccupied;
        int maxRoad[2];
        ErrorType mError;
    };
 
    class NetLayoutJunctionHash : public QHash<NetLayoutPoint,NetLayoutJunction*>
    {
    public:
        NetLayoutJunctionHash()  = default;
        ~NetLayoutJunctionHash() = default;
        void clearAll();
    };
 
    uint qHash(const LaneIndex& ri);
}
 
#ifdef JUNCTION_DEBUG
    void setColorMap(const hal::NetLayoutJunctionEntries& entries);
    QColor colorFromId(u32 netId);
#endif