RoadsState.h

Go to the documentation of this file.

#ifndef ROADS_STATE
#define ROADS_STATE

#include <vrecko/Ability.h>
#include <vrecko/ReaderWriter.h>
#include <vrecko/IOPins.h>
#include <vrecko/Message.h>

#include "Junction.h"
#include "PolygonPoint.h"
#include "Edge.h"
#include "RoadsEdges.h"
#include "CarControlUnit.h"

#include <osg/Vec3>
#include <set>
#include <map>
#include <vector>

namespace CarSim {

    using namespace vrecko;

    class RoadsState: public vrecko::Ability {
        public:
            // bude jenom 1 RoadsState, takze by nektere metody a atributy
            // mohly byt static, pro jednoduchost ale zatim budou vsechny metody
            // a atributy bez static, takze se budou vzdy vztahovat k instanci
            // RoadsState a ne k samotne tride
            RoadsState();
            ~RoadsState() {};
            void preInitialize(void);
            void processEvent(const std::string &input_name, void *value);
            void *processRequest(const std::string &input_name, void *value);

            virtual void update(void);
            
            bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);
        protected:
            // cesta k adresari, kde jsou ulozeny modely aut a textura silnice
            std::string dataPath;
            // jestlize je true, nektere krizovatky uvedene u from, to a fromPointRight,
            // toPointRight u hran zadanych v XML souboru neexistuji.
            // Tato promenna se kontroluje pri prijeti requestu a v pripade, ze je "true"
            // -> posle se NULL CCU -> ktera pak zrusi sve aktualizovani,
            // aby se uz neposilala zadosti roadsState
            bool invalidRefToJuncOrPolygPoint;
            
            // roads, junctions a polygonPoints jsou indexovany pomoci klicu,
            // ktere se vyskytuji jako id ve vstupnim XML souboru - zacinaji tedy
            // od 1 a v rozsahu pro klic se mohou vyskytovat diry;
            // indexy pro edges jsou generovany az pri behu programu - jsou indexovany
            // od 0 a v rozsahu pro index se nevyskytuji diry;
            // graf silnic - implementovan pomoci seznamu (mnoziny) nasledniku;
            // prvni unsigned int slouzi pro ID krizovatky (uzlu),
            // druhe znaci ID nasledniku (krizovatek) a posledni je ID hran
            // k temto naslednikum;
            // budou zde pouze hrany, na kterych auta jezdi z bodu OUT do IN
            // - tedy pouze normalni nebo kratke s aspon 1 pruhem (jestlize je hrana
            // prilis uzka na to, aby na ni mohlo jezdit auto -> ma 0 pruhu)
            std::map<unsigned int, std::map<unsigned int,unsigned int> > roads;
            std::map<unsigned int,Junction> junctions;
            // id krizovatky s nejvetsi hodnotou
            unsigned int maxJuncId;
            // id polygonPointu s nejvetsi hodnotou
            unsigned int maxPolygonPointId;
            std::map<unsigned int,PolygonPoint> polygonPoints;
            std::vector<Edge> edges;

            // pocet neterminalnich hran v edges (ze zacatku jsou
            // v edges neterminalni hrany, pak same terminalni)
            unsigned int numOfNonTermEdges;

            // zde budou ulozeno, ktere hrany patri k jakym silnicim;
            // klic je id silnice (budou zde vsechny silnice nactene
            // z XML souboru
            std::map<unsigned int,RoadsEdges> roadsEdges;

            // ukazatel na abilitu, ktera bude mazat auta
            Ability *pRemover;

            // ukazatel na abilitu, ktera bude cachovat casti geometrie aut, aby
            // se stejne soubory nemusely nacitat vicekrat
            Ability *pCarPartsNodeCache;
            
            // model sloupu semaforu,
            osg::Node *pTLcolumnModel;
            // model oranzoveho svetla semaforu,
            osg::Node *pTLorangeModel;
            // vzdalenost mezi stredy barevnych svetel na semaforu
            float tlColorsCenterDist;


            // loaded from params, should be used when the roads will be loaded:
            bool bDrawRoads;
            int iNumGenCars;
            bool bGenShortestPaths;

            bool bAttemptToLoadRoadsFromArtificalWorld; // will be used when road are not specified in the Parameters node

            
            // tato metoda nacte ze vstupniho XML souboru krizovatky (Junction),
            // body urcujici tvary silnic (PolygonPoint) a silnice (Road) pomoci
            // nasledujicich tri fci
            void loadJuncPolyRoad(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode const *const pRoadNetNode);
            // tato metoda nacte krizovatku z atributu uzlu Junction
            void loadJunction(XERCES_CPP_NAMESPACE_QUALIFIER DOMNamedNodeMap const *const pAttributes);
            // tato metoda nacte bod pro tvar silnice z atributu uzlu PolygonPoint
            void loadPolygonPoint(XERCES_CPP_NAMESPACE_QUALIFIER DOMNamedNodeMap const *const pAttributes);
            // tato metoda nacte silnici (Road) z atributu uzlu Road a ulozi ji pomoci
            // dvou hran protichudnych smeru (po teto metode je tedy v edges vzdy hrana se
            // sudym indexem komplementarni s hranou s tim indexem + 1)
            void loadRoad(XERCES_CPP_NAMESPACE_QUALIFIER DOMNamedNodeMap const *const pAttributes);
            
            // tato metoda vytvori polygon pro kazdou hranu a ulozi je pod 1 EnvironmentObject
            // do sceny (vykreslene polygony maji body from, fromPointRight, toPointRight, to)
            void addEdgesAsEO() ;
            // tato metoda overi, zda krizovatky uvedene u from, to a fromPointRight,
            // toPointRight u hran zadanych v XML souboru skutecne existuji
            void checkEdgesFromToAndTheirPolygonPoints();
            
            // metoda, ktera najde nejkratsi cestu ze startovni hrany s offsetem na ni
            // do koncove hrany s prislusnym offsetem;
            // vysledek bude ulozen do vektoru, na ktery ukazuje prvni ukazatel,
            // cesta je ulozena v podobe indexu krizovatek na ceste do mapy junctions
            void findShortestPath(std::vector<unsigned int> *const pResultPath,
                const StartStopDestination *const pStartStopDestination);

            // metoda, ktera najde ze startovni hrany nahodne dlouhou cestu (rand(30)+1,
            // delka cesty tu je v poctu hran na ni), ktera nemusi byt nejkratsi;
            // bude se predpokladat, ze auto na hrane startEdge muze zacit (pro auto uz byla
            // zavolana metoda regCarForEdge);
            // posledni hrana bude normalni (pujde na ni zastavit);
            // vysledek bude ulozen do vektoru, na ktery ukazuje ukazatel,
            // cesta je ulozena v podobe indexu krizovatek na ceste do mapy junctions;
            // slouzi pro rychlejsi nalezeni cest u generovanych aut;
            // pozn.: pocita se s tim, ze byl inicializovan generator nahodnych cisel srand();
            // pri generovani cesty se metoda bude snazit vybirat dalsi krizovatky po startovni hrane
            // tak, aby se auto prilis casto neotacelo o 180
            // (na krizovatkach to v realu neni prilis obvykle)
            void findPath(std::vector<unsigned int> *const pResultPath,const unsigned int startEdge);

            // tato fce vypocita pomoci indexu hrany a relativni pozici na ni
            // mezi body OUT a IN
            // absolutni pozici ve svete, ta se ulozi to 1. parametru;
            // offset je v procentech
            void getAbsPos(osg::Vec3 &resultPos,const unsigned int edge,
                const float offset);

            // tato metoda vypocita u vsech neterminalnich hran atributy: body IN a OUT,
            // outInVec, widthTPR, widthFPR, type a dalsi
            void computeEdgesAttributes();

            // tato metoda pred zapocetim simulace prida ke kazde krizovatce
            // indexy na neterminalni hrany, ktere do ni vstupuji a vystupuji;
            // budou slouzit k detekci prechodu auta pres hranice hran
            // krizovatky u ktere je auto
            void computeJunctionsEdges();

            /*// tato fce vypocte prusecik usecky a roviny, ktere jsou k sobe kolme;
            // usecka je zadana pomoci bodu a vektoru (u usecky vektor definuje
            // jeji delku), rovina je definovana pomoci bodu a vektorem usecky;
            // jestlize prusecik puvodni primky a usecky neexistuje, vrati se NULL
            const osg::Vec3 *const interPointOfAbscissaAndPerpendicularPlane
                (const osg::Vec3 &abscissaPoint,const osg::Vec3 &abscissaVec,const osg::Vec3 &planePoint);*/

            // tato fce vypocte prusecik (1. parametr) primky a roviny, ktere jsou k sobe kolme;
            // primka je zadana pomoci bodu a vektoru, rovina je definovana pomoci bodu a vektorem primky;
            // jestlize je lineVec (0,0,0), bude vypsana chyba a vraceny prusecik bude (0,0,0)
            void interPointOfLineAndPerpendicularPlane(osg::Vec3 &inter,const osg::Vec3 &linePoint,
                const osg::Vec3 &lineVec,const osg::Vec3 &planePoint);

            // vypocita vzdalenost mezi primkou (zadana bodem a vektorem) a bodem v prostoru
            const float distFromPointToLine(const osg::Vec3 &linePoint,
                const osg::Vec3 &lineVec,const osg::Vec3 &point);

            void herFerDeriv(osg::Vec3 &result,const float d,const osg::Vec3 &P1,
                const osg::Vec3 &P4,const osg::Vec3 &R1,const osg::Vec3 &R4);

            /*// tato metoda vypocita pozici Hermite/Fergussonovy kubiky (danou body 
            // P1, P4 a vektory R1 a R4) v bode d, vysledek ulozi do result
            void herFer(osg::Vec3 &result,const float d,const osg::Vec3 &P1,
                const osg::Vec3 &P4,const osg::Vec3 &R1,const osg::Vec3 &R4);*/

            // tato funkce zjisti, zda bod point lezi v poloprostoru zadanym vektorem
            // halfSpacePoint a bodem halfSpaceVec
            bool pointInHalfSpace(const osg::Vec3 &point,const osg::Vec3 &halfSpacePoint,
                                  const osg::Vec3 &halfSpaceVec);

            // jestlize je auto v okoli stredu krizovatky, urci se na ktere hrane je,
            // ta se pak vrati v prvnim parametru; 
            // 2. parametr je index hrany, na ktere bylo auto v minulem snimku
            // 3. parametr je spodni pozice auta,
            // 4. parametr je index krizovatky, u ktere je auto (sloucene, nikdy dilci)
            // 5. parametr je id vystupni hrany u te krizovatky
            void getCarEdgeId(unsigned int &carEdgeId,const unsigned int lastCarEdgeId,
                const osg::Vec3 &bottomCarPosition,const unsigned int juncId,
                const unsigned int outEdgeId);

            // v prvnim parametru vrati vzdalenost bodu point od roviny
            // dane bodem (planePoint) a vektorem (planeNormal)
            void distPointToPlane(float &dist,const osg::Vec3 &point,
                const osg::Vec3 &planePoint,const osg::Vec3 &planeNormal);

            // tato metoda vypocte ve 2D prunik 2 ruznobeznych primek 
            // (jsou dany bodem a vektorem), vysledek je ulozen do result;
            // jestlize jsou primky rovnobezne, zapise se chybova hlaska a vrati 
            // se (0,0,0)
            void linesInter2D(osg::Vec2 &result,const osg::Vec2 &line1Point,
                const osg::Vec2 &line1Vec,const osg::Vec2 &line2Point,
                const osg::Vec2 &line2Vec);

            // metoda najde u krizovatek pary samostatnych polygonPointu
            // (samostatnych ve smyslu jejich vyskytu u hran krizovatky), ktere jsou vedle
            // sebe (1. je vzdy na vstupni, 2. na vystupni hrane) a zavola metodu, ktera
            // z tech 2 polygonPointu a stredu krizovatky udela terminator;
            // terminatory se pridavaji, aby auto pri prejeti kolem tech
            // samostatnych polygonPointu nevyselo jenom tak ve vzduchu (aby se autu
            // mohla snadno davat normala podle hrany pod nim, aby se jednoduse urcilo,
            // kde auto je)
            void findJuncsSinglePolyPoints();

            // tato metoda vytvori z 1. a 2. sam. polygonPointu a stredu kriz. juncId
            // terminator (viz findJuncsSinglePolyPoints); terminator se take zacleni
            // mezi hrany fstEdgeId (lezi na ni 1. polygonPoint, je to vzdy vstupni
            // hrana) a sndEdgeId (lezi na ni 2. polygonPoint, je to vzdy vystupni hrana)
            // v orderedEdges krizovatky juncId
            void addTerminatorEdges(unsigned int fstSinglePolyPoint,
                unsigned int sndSinglePolyPoint,unsigned int fstEdgeId,
                unsigned int sndEdgeId,const unsigned int juncId);

            // mezi nekterymi krizovatkami se mohou vyskytnout hrany, ktere jsou
            // ultrakratke (viz Edge.h);
            // neni vhodne uvazovat prujezd pres tuto ultrakratkou hranu
            // z bodu OUT a IN, protoze by pak auto muselo na takove hrane prudce zatacet;
            // proto krizovatky, mezi nimiz jsou ultrakratke hrany,
            // spojuji do jedne nove krizovatky;
            // ta ma vstupni a vystupni hrany stejne jako neultrakratke vstupni a vystupni
            // hrany dilcich krizovatek;
            // v edges jsou odkazy na stare krizovatky; v roads se odstrani stare krizovatky
            // a daji nove
            void mergeCloseJunctions();

            // prida hranu s id edgeId jako EnvironmentObject do sceny (s geometrii ctyruhelnika)
            void addEdgeAsEO(const unsigned int edgeId);

            // tato metoda usporada hrany u krizovatek ulozenych ve vektoru orderedEdgesIds
            void orderJunctionsEdges();
            
            // tato metoda vypocita u krizovatek atributy pro dvojice vstupnich a vystupnich
            // (ovsem vzdy kratkych nebo normalnich) hran, viz junction.h; predpoklada se,
            // ze hrany u krizovatek jsou uz usporadane
            void computeJuncInOutEdgesAttr();

            // jestlize auto skoncilo svoji cestu -> smaze se jeho id u koncove (normalni) hrany;
            // tato metoda smaze id na auto u dane hrany; nemuze se stat, ze by
            // se id auta u hrany nenaslo -> proto tuto moznost netestuji
            void unregCarForEdge(const unsigned int carId,const unsigned int edgeId);

            // odregistuje posledni auto na zadane normalni hrane
            void unregLastCarForEdge(const unsigned int edgeId);

            // zaregistruje auto u startovni (normalni) hrany
            // (parametry jsou - id auta, id startovni hrany, offset pozice stredu auta na ni,
            // delka auta a zda bylo auto vygenerovano);
            // pridani auta do hrany, kde uz nejaka auta jsou, bude mit
            // linearni slozitost - to ale nebude moc vadit, protoze to nebude moc caste
            // (auto se zaregistuje u hrany pouze na zacatku sveho zivotniho cyklu);
            // jestlize vse probehlo v poradku, vrati true;
            // jestlize se vyskytla chyba (auto je moc blizko jinemu autu, ktere uz
            // na hrane je; predni cast auta je za bodem stopBeforeJunc nebo je prilis blizko 
            // autu u from kriz. hrany), vrati false;
            // jestlize je showErrors false, budou potlaceny chybove vystupy (napriklad pri
            // generovani aut)
            bool regCarForEdge(const unsigned int carId,const unsigned int startEdgeId,
                const float startOffset,const float carLength,const bool showErrors);

            // zaregistruje auto s offsetem (urcujicim umisteni stredu auta na hrane), delkou
            // a rychlosti u normalni hrany jako prvni
            void regFstCarForEdge(const unsigned int carId,const unsigned int edgeId,
                const float offset,const float carLength,const float vel);

            // zjisti, zda je auto zaregistrovano u hrany
            bool isCarRegForEdge(const unsigned int carId,const unsigned int edgeId);

            // metoda, ktera aktualizuje informace o autu u normalni hrany
            // (auto musi byt zaregistrovano u normalni hrany)
            void updateCarForEdge(const unsigned int carId,const unsigned int edgeId,
                const float headOffset,const float rearOffset,const float vel);

            // metoda, ktera vrati vzdalenost mezi autem, jehoz id je dano parametrem
            // (auto musi byt zaregistrovano u hrany s id edgeId), a autem nasledujicim
            // (smerem ke konci hrany) a rychlost tohoto nasledujiciho auta;
            // pozadovane hodnoty jsou vraceny v prvnich dvou parametrech;
            // Pozn.: Jestlize nasledujici auta neexistuje, jsou vracene hodnoty 0
            void getNextCarDistAndVel(float &nextCarDist,float &nextCarVel,
                const unsigned int carId,const unsigned int edgeId);

            // tato metoda overi, zda je cilova pozice na koncove (normalni) hrane pro auto 
            // povolena (vrati true) nebo zakazana (false);
            // jestlize auto chce skoncit svou predni casti pred bodem stopBeforeJunc
            // hrany a zaroven svou zadni casti za bodem, ktery urcuje lowBoundForStartStopPosOffset
            // u hrany (auto by melo byt schopno po vyjezdu ze krizovatky zabrzdit tak, aby v cili
            // melo temer nulovou rychlost), ma auto povoleni tu skoncit;

            // Pozn.: Auto bude moci skoncit tam, kde zacalo.

            // parametry jsou:
            // stopEdgeId - id koncove hrany
            // stopOffset - relativni pozice mezi Out a In (in (0,1))
            // carLength - delka auta
            bool isCarStopPositionRight(const unsigned int stopEdgeId,const float stopOffset,
                                        const float carLength);

            // metoda, ktera vrati, zda je na zacatku normalni hrany edgeId dostatek 
            // mista pro skupinu aut (ktere na ni chteji vjet), kterych je carCount a ve ktere ma
            // prvni auto (vzhledem ke smeru hrany) delku fstCarInGroupLength a vsechna ostatni
            // v ni maximalni moznou delku 
            bool isFreeSpaceForCarGroupOnEdge(const unsigned int edgeId,const float fstCarInGroupLength,unsigned int carCount);
            
            // pokud krizovatka je
            // bez pridavneho jmena velka, je mala - jedna se bud o krizovatku sloucenou z puvodnich
            // krizovatek pres velmikratke hrany nebo puvodni krizovatku, ktera neni sloucena s jinymi
            // pres velmi kratke hrany; 
            // ve starsim kodu muze znamenat krizovatka take proste puvodni krizovatku 
            // (TODO oprav starsi komentare, aby neplatilo?);
            // velka krizovatka vznika spojenim krizovatek pres kratke hrany nebo se jedna o krizovatku,
            // kolem ktere neni zadna kratka hrana;
            // nijak se pred simulaci nevypocitavaji (narozdil od malych krizovatek sloucenych pres
            // velmikratke (ultrakratke) hrany);
            // pri prujezdu malymi krizovatkami bude auto porad zatacet;
            // ve velke kriz. bude zatacet pouze v oblastech malych kriz.;

            // hrany k zamceni se oproti klasickym hranam lisi v nasledujicich bodech:
            // a) normalni vstupni hranu do male nebo velke krizovatky tvori pouze cast za bodem In,
            // obdobne normalni vystupni hranu z male ci velke krizovatky predstavuje cast pred
            // bodem Out
            // b) jestlize auto jede (pojede) po cele delce kratke hrany, pocita se dvakrat;
            // je rozdelena na dve u bodu OUT, jedna cast patri ke krizovatce from (nebo te,
            // do niz se sloucila), druha cast ke krizovatce to (nebo te, do niz se sloucila);
            // c) pokud neni receno jinak, jsou hrany mezi pro auto vstupni a vystupni hranou do/z
            // male krizovatky brany jako jedna hrana - sloucena hrana (sklada se z dilcich hran);
            // pozn.: pokud se ve spojitosti s nejakou hranou budu zminovat o zamykani, odemykani
            // a podobne, bude ta hrana hrana k zamceni
            // pozn.: sloucena hrana se povazuje za odemcenou, jestlize jsou vsechny jeji dilci
            // hrany odemcene

            // auto se rozhoduje, zda vjede do velke krizovatky
            // u bodu stopOrGoDecision vstupni normalni hrany;
            // auto pojede, jestlize:
            // I. je posledni auto na vstupni hrane
            // II. a) jsou vsechny hrany mezi hranou, na ktere auto je
            // a nejblizsi normalni vystupni (pro auto) hranou (vcetne) odemcene nebo 
            // b) pokud je nejaka z vyse zminenych hran zamcena na nejake male krizovatce,
            // musi jet na te male krizovatce stejnou cestou jako posledni auto,
            // ktere si u ni zamklo nejake hrany (ta hrana u te male krizovatky muze
            // byt zamcena, jelikoz uvedena auta v ni pojedou zhruba stejnou rychlosti, kdyz
            // v ni pojedou stejnou cestou - takze si nebudou zavazet) 
            // III. jestlize je velka krizovatka rizena semafory (v tom pripade se velka krizovatka
            // sklada pouze z jedne male) na vstupni normalni hrane sviti autu zelena; v opacnem
            // pripade na vsech malych krizovatkach v te velke muze jet podle pravidla prave ruky
            // IV. na te vystupni hrane je pro auto dostatek mista;
            // jen pro velkou krizovatku nerizenou semafory:
            // jestlize auto na nektere male krizovatce (ve velke krizovatce) muze jet
            // podle pravidla prave ruky pouze diky deadlocku, musi byt na vystupni
            // normalni hrane z te velke krizovatky dost mista pro auto s maximalni moznou
            // delkou (+ rezerva). (dve auta chteji jet na stejnou vystupni normalni hranu; jedno by
            // mohlo jet pouze diky uvaznuti, druhe by to zvladlo i bez nej; pak prvni auto
            // musi vyrazit pozdeji nez druhe bez ohledu na jejich delky);
            // pokud autu zatim nebyl zamitnut vjezd do velke krizovatky a v ceste auta pres
            // velkou krizovatku je zamcena nejaka hrana, na zacatku vystupni normalni hrany
            // musi byt za vyse pozadovanym mistem pro auto navic misto pro tolik aut
            // s maximalni moznou delkou, kolikrat je ta vystupni normalni hrana zamcena 
            // V. jen pro velkou krizovatku nerizenou semafory:
            // jestlize auto na nektere male krizovatce (ve velke krizovatce) muze jet
            // podle pravidla prave ruky pouze diky deadlocku, nesmi byt v poslednim snimku
            // nejakeho auta na zadne te male krizovatce byt odemcena hrana (ve snimku po
            // odemceni hrany musi mit prednost auta, ktera mohou jet bez uvaznuti, pred
            // vozidly, ktera to zvladnou jenom s nim)
        
            // jestlize auto muze jet (splnuje postupne vsechny predchozi podminky),
            // zamcou se vsechny zminene hrany (jestlize auto pojede pres
            // nejake hrany vicekrat, take se tim autem vicekrat zamcou; vicenasobne (2x a vic)
            // zamceni hrany muze byt zpusobene take tim, ze nejaka hrana z tech hran, pres
            // ktere auto pojede ve velke krizovatce, jiz byla zamcena),
            // u malych krizovatek, pres ktere auto pojede, se nastavi cesta, kudy jelo posledni
            // auto, ktere u nich zamcelo nejakou hranu a vrati se true, v opacnem pripade se
            // vrati false

            // Pozn.: Jestlize by se zamykala treba jen pristi hrana (ne vsechny najednou),
            // hrozilo by, ze se auto svym stredem v dolni podstave ocitne na jim
            // nezamcene hrane.

            // parametry:
            // pPath - ukazatel na vektor, kde jsou ulozeny vsechny krizovatky (jejich id)
            //      v ceste auta
            // lastJuncInPath - mala krizovatka, ze ktere auto jede, je vyjadrena indexem
            //      v ceste path (na zacatku tedy index 0)
            // isLastCar - rika, zda auto je posledni na vstupni hrane
            // isStopedCar - rika, zda auto stoji pred velkou krizovatkou (bude se hodit pri
            //      reseni deadlocku v metode rightHandRule (slouzi pro zjisteni, zda auto muze
            //      jet na nejake male krizovatce v te velke podle PPR))
            // carLength - delka auta (slouzi ke zjisteni, zda je na vystupni normalni
            //    hrane pro auto dostatek mista)
            // carId - id auta (potrebne pro metodu rightHandRule)
            bool lockJuncsEdgesForNewCar(const std::vector<unsigned int> *const pPath,
                const unsigned int lastJuncInPath,const bool isLastCar,const bool isStopedCar,
                const float carLength,const unsigned int carId);

            // najde pro auto (s id == carId) sekvenci kratkych hran (pres ktere auto pojede
            // v pristi velke krizovatce z Out do In), ktera zacina pristi vystupni hranou 
            // (roads[(*pPath)[lastJuncInPath+1]][(*pPath)[lastJuncInPath+2]]);
            // u vsech techto hran metoda zaznamena, ze pres ne auto pojede (z Out do In) ve
            // sve pristi velke krizovatce, je na normalni hrane posledni a je blizko
            // dalsi krizovatky (tak, ze ostatni auta, ktera pojedou pres casti tech kratkych
            // hran za jejich body In, zvazuji, zda mu daji prednost)
            
            // parametry:
            // pPath - ukazatel na vektor, kde jsou ulozeny vsechny krizovatky
            //      v ceste auta
            // lastJuncInPath - mala krizovatka, ze ktere auto jede, je vyjadrena indexem
            //      v ceste path (na zacatku tedy index 0)
            // carId - id auta
            void regIncomingCarToShortEdges(const std::vector<unsigned int> *const pPath,
                const unsigned int lastJuncInPath,const unsigned int carId);

            // najde pro auto (s id == carId) sekvenci kratkych hran (pres ktere
            // auto pojede v pristi velke krizovatce z Out do In), ktera zacina
            // pristi vystupni hranou 
            // (roads[(*pPath)[lastJuncInPath+1]][(*pPath)[lastJuncInPath+2]]);
            // u vsech techto hran metoda zaznamena, ze auto je na normalni hrane
            // posledni a stoji

            // parametry:
            // pPath - ukazatel na vektor, kde jsou ulozeny vsechny krizovatky
            //      v ceste auta
            // lastJuncInPath - mala krizovatka, ze ktere auto jede, je vyjadrena indexem
            //      v ceste path (na zacatku tedy index 0)
            // carId - id auta
            void setStopedIncomingCarToShortEdges(const std::vector<unsigned int> *const pPath,
                const unsigned int lastJuncInPath,const unsigned int carId);

            // tato metoda resi pravidlo prave ruky, auto vjizdi do male krizovatky
            // pres vstupni hranu inEdge;

            // auto ma povoleni jet podle pravidla prave ruky, jestlize:
            // I. pro vsechny jeji normalni a kratke vstupni hrany, pres ktere auto chce jet a
            // se kterymi svira hrana, pres kterou chce vjet vozidlo do krizovatky, uhel mensi
            // nez 135°, plati:
            //   a) pro normalni hranu: posledni auto je pred bodem, ktery je vzdalenost d
            //   pred bodem stopOrGoDecision (tedy krome tohoto auta samotneho - auto si
            //   nebude davat prednost samo sobe - to by se mohlo stat, kdyz by auto jelo
            //   pres cyklus kratkych hran a nebylo by to osetrene - i s timto autem by se
            //   pocitalo);
            //   (d je vzdalenost toho auta potrebna ke zpomaleni na 0-ovou rychlost +
            //   2*prumerna delka auta)
            //   b) pro kratkou hranu: neexistuje zadne auto, ktere pres ni pojede (z Out do In)
            //   ve sve pristi velke krizovatce, je posledni na normalni hrane a nachazi se tak
            //   blizko dalsi krizovatky, ze mu toto vozidlo musi dat prednost
            //   (toto auto se nepocita -> auto nebude davat prednost samo sobe - to by
            //   se mohlo stat, kdyz by auto jelo pres cyklus kratkych hran a i toto
            //   auto by se pocitalo)
            // II. vozidlo stoji na hrane jako posledni a na krizovatce jsou uvazla auta
            // (nastal deadlock)

            // jestlize auto to povoleni ma, vrati se true, v opacnem pripade false
            
            // parametry:
            // withDeadlock - rika zda auto ma povoleni jet podle prave ruky pouze
            //      diky uvaznuti (deadlock)
            // inEdge - vstupni hrana pro auto do male krizovatky
            // outEdge - vystupni hrana pro auto z male krizovatky
            // juncId - id male krizovatky
            // isCarLastStoped - rika, zda auto, pro ktere se zjistuje PPR, 
            //      stoji pred velkou krizovatkou jako posledni auto na hrane,
            //      bude se hodit pri reseni deadlocku
            // carId - id auta
            bool rightHandRule(bool &withDeadlock,const unsigned int inEdge,const unsigned int outEdge,
                const unsigned int juncId,const bool isCarLastStoped,const unsigned int carId);
            
            // Tato metoda odemyka (ne vzdy uplne odemce) minulou hranu k zamceni -
            // dekrementuje u ni lockCount, viz lockCount u JuncsEdge.

            // Jestlize je auto na vystupni hrane a doslo k preskoceni prilis uzke sloucene hrany
            // (to se muze stavat pri nizkem fps), bude odemykana ta sloucena i vstupni hrana.

            // Pozn.: Auto muze byt poprve na sloucene hrane, i kdyz neni na jeji prvni dilci
            // hrane po vstupni hrane.

            // Metoda predpoklada, ze je volana pouze tehdy, jestlize doslo k prechodu pres hranu k zamceni.

            // Sloucena hrana se povazuje za odemcenou, jestlize jsou vsechny jeji dilci hrany odemcene.

            // parametry:
            // edgeId - aktualni hrana, na ktere je auto;
            // lastJuncId - minula krizovatka, bude urcovat vstupni hranu do krizovatky,
            //      u ktere je auto
            // nextJuncId - id male krizovatky, u ktere je auto
            // nextNextJuncId - id male kriz. po ni
            // mergedEdgeSkiped - rika, zda doslo k preskoceni prilis uzke sloucene hrany
            // carId - id auta
            void decreaseLockCountForPrevEdge(const unsigned int edgeId,
                const unsigned int lastJuncId,const unsigned int nextJuncId,
                const unsigned int nextNextJuncId,const bool mergedEdgeSkiped,
                const unsigned int carId);

            // tato metoda vypocita doporucenou rychlost na krizovatce s id juncId
            // pro auto, ktere jede ze vstupni hrany inEdge do vystupni hrany outEdge
            void computeRecVelocityOnJunc(float &recVel,const unsigned int juncId,
                const unsigned int inEdge,const unsigned int outEdge);

            // metoda urci typ zatoceni (doleva, doprava, rovne) na krizovatce juncId,
            // na ktere auto jede ze vtupni hrany inEdge na vystupni hranu outEdge,
            // vysledek vrati v prvnim parametru
            void getTurnOnJunc(unsigned int &turnOnJunc,const unsigned int juncId,
                const unsigned int inEdge,const unsigned int outEdge);

            // metoda, ktera na zacatku simulace nahodne vygeneruje auta,
            // bude jich numOfGenCars; parametr genShortestPath urcuje, zda vygenerovane cesty
            // maji byt nejkratsi (ze startovni do koncove hrany)
            void generateCars(const unsigned int numOfGenCars,const bool genShortestPath);

            // pro debugovani umisti na bod malou zelenou krychlicku
            void showPoint(const osg::Vec3 &point);

            // rika, zda u male krizovatky juncId vznikl deadlock (uvzaznuti), vznikl jestlize:
            // a) jsou vsechny vstupni a vystupni hrany krizovatky odemcene
            // b) na zadne vstupni normalni hrane neni auto, ktere je na ni posledni
            // a ktere jede (nestoji)
            // c) na zacatky vsech vystupnich normalnich hran se vejde auto
            // s maximalni moznou delkou (ke ktere je pripoctena mala rezerva)
            // (auto libovolne delky, ktere ceka pouze na to, az se pro nej na vystupni hrane
            // uvolni misto, musi projet krizovatku drive nez vozidlo, ktere pres ni muze
            // jet pouze diky uvaznuti) nebo na nich musi prvni auto stat
            // d) pro zadnou kratkou vstupni hranu neexistuje auto, ktere pres ni pojede (z Out
            // do In) ve sve pristi velke krizovatce, je na normalni hrane posledni, nachazi se
            // blizko dalsi krizovatky (tak, ze auta u krizovatky juncId zvazuji, zda mu nedaji
            // prednost) a ktere jede (nestoji)
            // e) v poslednim snimku nedoslo k odemceni hrany u krizovatky (pokud se na
            // krizovatce nebo v jeji tesne blizkosti neco deje, neni zablokovana)

            // Pozn.: ma vyznam pouze pro male krizovatky ve velkych krizovatkach, ktere nejsou
            // rizeny semafory; jestlize je velka krizovatka rizena semafory, je vzdy tvorena pouze
            // jednou malou krizovatkou, na ktere nemuze vzniknout deadlock
            bool isDeadlock(const unsigned int juncId);
            
            // tato metoda nacte ze vstupniho XML souboru z elementu TLparameters
            // cesty k souborum s geometriemi (modely) casti semaforu, ktere nasledne take nacte,
            // dale take nacte vzdalenost mezi stredy barevnych svetel semaforu 
            void loadTLparameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *const pTLparametersNode);

            // metoda, ktera vytvori semafory na krizovatkach, ktere jsou rizeny semafory
            void createTrafficLights(void);

            // zkontroluje, zda krizovatka (mala) s id juncId splnuje kriteria pro krizovatku se semafory 
            // (pro jednoduchost se mala krizovatka, ktera je rizena semafory, vyskytuje ve
            // velke krizovatce vzdy sama a propojuje 3-4 silnice, v nichz jsou alespon 2 normalni 
            // hrany, ktere smeruji do krizovatky a alespon 1 normalni hrana, ktera smeruje ze krizovatky);
            // kriteria jsou splnena -> vrati true, jinak false
            bool isValidJuncWithTLs(unsigned int juncId);

            DECLARE_INPUT(InUnregCarForEdge, MessageCarEdge);
            DECLARE_INPUT(InAddForEdgeRegisteredCarToPutAsideCars, MessageCarEdge);

            DECLARE_REQUEST_INPUT(InGetReady, MessageVoid, MessageBool);
            DECLARE_REQUEST_INPUT(InGetDataPath, MessageVoid, MessageString);
            DECLARE_REQUEST_INPUT(InGetEdgeAbsPos, MessageEdgeOffset, MessageVec3);
            DECLARE_REQUEST_INPUT(InGetEdgeOutInVec, MessageUnsignedInt, MessageVec3);
            DECLARE_REQUEST_INPUT(InGetEdgeNormal, MessageUnsignedInt, MessageVec3);
            DECLARE_REQUEST_INPUT(InFindShortestPath, MessageStartStopDestination, MessageVectorUnsignedInt);
            DECLARE_REQUEST_INPUT(InCheckCarStopPosition, MessageCarEdgeData, MessageBool);
            DECLARE_REQUEST_INPUT(InGetStartOrStopEdgeFromRoadAndDirection, MessageRoadAndDir, MessageUnsignedInt);
            DECLARE_REQUEST_INPUT(InRegCarForEdge, MessageCarEdgeData, MessageBool);
            DECLARE_REQUEST_INPUT(InGetRecVelOnJunc, MessageFirst3Juncs, MessageFloat);
            DECLARE_REQUEST_INPUT(InGetTurnOnJunc, MessageFirst3Juncs, MessageUnsignedInt);
            DECLARE_REQUEST_INPUT(InIsCarFstPutAsideOnEdge, MessageCarEdge, MessageBool);
            DECLARE_REQUEST_INPUT(InRegisterPutAsideCarForEdge, MessageCarEdgeData, MessageBool);
            DECLARE_REQUEST_INPUT(InGetCarEnvirons, MessageCarSimParameters, MessageCarEnvirons);
    };
    
}

#endif