Edge.h

Go to the documentation of this file.

#ifndef EDGE
#define EDGE    
// kazda hrana ma komplementarni hranu (pouze s prohozenymi krizovatkami
// fromJunction, toJunction); jestlize ma hrana numLanes 0, je nesjizdna
// (auta na ni nemuze jet z bodu Out do In)

// hrany jsou vetsinou normalni, vyjimky tvori nasledujici pripady
#define NORMAL_EDGE      1
// ultrakratka (nebo take velmi kratka) hrana - ma nejaky pruh a splnuje nejmene
// 1 z podminek:
// 1. vzdalenost mezi from a to hrany je <= nez 1.5*prumerna delka auta
// 2. bod OUT vychazi az za bod IN (bod In vychazi blize krizovatce fromJunction
// nez bod Out)
// 3. pro komplementarni hranu plati predchozi podminka
#define ULTRA_SHORT_EDGE 2
// ultrakratka hrana bez pruhu
#define ULTRA_SHORT_EDGE_WITHOUT_ANY_LANE 3
// kratka hrana � hrana se povazuje za kratkou, pokud neni velmi kratka, ma
// nejmene jeden pruh a splnuje alespon jedno z tvrzeni: 
// a) teoreticky existuje auto (s maximalni moznou delkou, ktere by u bodu Out
// vyjelo maximalni moznou rychlosti prujezdu krizovatkou), ktere na ni nemuze
// zastavit, aniz by ohrozilo provoz na krizovatce pred nim nebo za nim;
// jinymi slovy vzdalenost mezi OUT a IN <= 3*prumerna delka auta + 0.4 (rezerva)
// (mezi autem, ktere stoji na normalni hrane a bodem IN
// ci bodem OUT by mela byt vzdy vzdalenost aspon 0.5 * prumerna delka auta)
// b) hrana ma komplementarni kratkou hranu
#define SHORT_EDGE       4
// normalni nebo kratka hrana bez pruhu
#define NORMAL_OR_SHORT_EDGE_WITHOUT_ANY_LANE 5
// program ACG vynechava silnice na kraji mesta pri vytvareni jejich XML reprezentace;
// kolem stredu nekterych krizovatek tak vznikaji prazdna mista, ktera jsou zaplnena
// specialnimi hranami - terminatory
#define TERMINATOR_EDGE  6

// defaultni hodnota pro tlGreenInterv
#define TL_GREEN_INTERV_DEFAULT 6

#include <queue>

namespace CarSim {
    // u normalni hrany budou uchovany nektere informace o autu,
    // jestlize na ni bude mezi body OUT a IN:
    struct EdgesCar {
        // offset predni casti auta (predniho narazniku) na hrane
        float headOffset;
        // offset zadni casti auta (zadniho narazniku) na hrane
        float rearOffset;
        // id dalsiho auta (0 - neplatne id - za autem se
        // zadne dalsi auto nevyskytuje)
        unsigned int frontCarId;
        // id predchoziho auta (0 - neplatne id - pred autem se
        // zadne predchozu auto nevyskytuje)
        unsigned int backCarId;
        // rychlost tohoto auta
        float vel;
    };

    // informace o hrane
    struct Edge {
        // id silnice (Road z XML souboru), ke ktere tato hrana patri
        unsigned int roadId;
        // smer hrany v ramci silnice (Road v XML souboru),
        // true urcuje normalni smer dopredu (pravou stranu silnice),
        // false znaci opacny smer v silnici (levou stranu silnice)
        bool direction;
        // id zakladni krizovatky (puvodni krizovatka z XML souboru),
        // ze ktere hrana vychazi
        unsigned int from;
        // id zakladni krizovatky, do ktere hrana vstupuje
        unsigned int to;
        // id krajniho bodu (PolygonPoint), ktery urcuje tvar
        // hrany, tento bod je u krizovatky from
        unsigned int fromPointRight;
        // to stejne, akorat tento bod je u krizovatky to
        unsigned int toPointRight;
        // pocet pruhu na hrane (v silnici v jednom smeru)
        unsigned int numLanes;
        // delka hrany
        float length;
        // IN je bod, kde auto vstupuje do krizovatky a kde auto zacne zatacet
        // (pouze pro kratke a normalni hrany, u ostatnich hran je [0,0,0])
        osg::Vec3 inPos;
        // bod, ve kterem auto prestane zatacet (kde auto vyjizdi ze krizovtky)
        // (pouze pro kratke a normalni hrany, u ostatnich hran je [0,0,0])
        osg::Vec3 outPos;
        // vektor z bodu OUT do bodu IN, jedna se o smer, jakym v idealnim pripade
        // pojede hranou auto;
        // (pouze pro kratke a normalni hrany, u ostatnich hran je [0,0,0])
        osg::Vec3 outInVec;
        // normala teto hrany (uz je znormalizovana)
        osg::Vec3 normal;
        // offset (ne v procentech, ale in (0,1)), ktery urcuje bod mezi body Out a In, kde auto
        // zastavi svym prednim naraznikem, jestlize se rozhodne zastavit pred dalsi krizovatkou;
        // ten bod se nachazi 0.5*(prumerna delka auta) pred bodem IN hrany;
        // mezi posledni stojicim autem na hrane a bodem IN se nechava prostor dlouhy
        // 0.5*(prumerna delka auta), aby auto neohrozilo provoz u nasledujici kriz.
        // (pouze pro normalni hrany, u ostatnich hran je 0)
        float stopBeforeJuncOffset;
        // offset (ne v procentech, ale in (0,1)), ktery urcuje bod mezi body OUT a IN, ktery
        // kdyz auto prejede svym prednim naraznikem, rozhodne se, jestli projede dalsi
        // krizovatkou hned nebo bude brzdit k bodu stopBeforeJunc (aby dalo nejakemu autu prednost);
        // tato pozice se nachazi 2.0*(prumerna delka auta) pred bodem IN hrany;
        // (pouze pro normalni hrany, u ostatnich hran je 0)
        float stopOrGoDecisionOffset;
        // typ hrany - hodnoty viz vyse 
        unsigned int type;
        // sirka hrany u bodu toPointRight;
        // (pouze pro kratke a normalni hrany, u ostatnich hran je 0)
        float widthTPR;
        // sirka hrany u bodu fromPointRight;
        // (pouze pro kratke a normalni hrany, u ostatnich hran je 0)
        float widthFPR;
        // offset, ktery urcuje bod, za kterym (smerem k bodu IN) se musi nachazet zadni cast
        // auta na startu a v cili; ten bod je vzdalen 0.5*prumerna delka auta
        // od bodu OUT a ocita se za timto bodem (smerem k IN);
        // (ma smysl pouze pro normalni hrany - auto musi zacinat a koncit na normalni hrane)
        float lowBoundForStartStopPosOffset;
        // jestlize hrana je normalni, jsou zde pro kazde auto (klic - id auta) na teto hrane
        // mezi OUT a IN ulozeny informace ve strukture EdgesCar
        std::map<unsigned int,EdgesCar> edgesCars;
        // id 1. auta na hrane mezi body OUT a IN;
        // (0 - neplatne id - na hrane jeste zadne auto neni);
        // (opet pouze pro normalni hrany)
        unsigned int fstCarId;
        // id posledniho auta na hrane mezi body OUT a IN;
        // (0 - neplatne id - na hrane jeste zadne auto neni);
        // (opet pouze pro normalni hrany)
        unsigned int lastCarId;

        // ma vyznam pouze u kratke hrany - jsou tam id aut, ktera pres ni pojedou
        // (z Out do In) ve sve pristi velke krizovatce, jsou posledni na normalni hrane
        // a jsou blizko dalsi krizovatky (tak, ze ostatni auta, ktera pojedou
        // pres cast te kratke hrany za bodem In, zvazuji, zda jim daji prednost); 
        // mapovana hodnota obsahuje true, jestlize auto na normalni hrane stoji
        std::map<unsigned int,bool> incomingCars;
        
        // u normalnich hran zde je fronta s id odsunutych/odskocenych aut
        // (byla docasne odsunuta, protoze branila prujezdu ostatnich aut
        // - stala pred bodem stopBeforeJunc hrany prilis dlouho);
        // prvni auto (vpredu fronty) bylo nejdrive odsunuto, posledni auto zase nejpozdeji
        // ze vsech aktualne odsunutych aut na hrane
        std::queue<unsigned int> putAsideCars;

        // pocet sekund, po ktere ma na semaforu u puvodni krizovatky to pro tuto hranu svitit
        // zelena (pokud puvodni krizovatka to ani ji nadrazena mala krizovatka (pokud se sloucila
        // do vetsi krizovatky) nejsou rizeny pomoci semaforu, nebude tato hodnota pouzita; tato hodnota
        // se nacita z XML konfiguracniho souboru, pokud v nem neni uvedena, pouzije se defaultni hodnota
        // - viz nahore)
        unsigned int tlGreenInterv;
    };
}

#endif