GUI_E2_ZS_CollectorOverLanes Class Reference

#include <GUI_E2_ZS_CollectorOverLanes.h>

Inheritance diagram for GUI_E2_ZS_CollectorOverLanes:

Detailed Description

The gui-version of a MS_E2_ZS_CollectorOverLanes.

Allows the building of a wrapper (also declared herein) which draws the detector on the gl-canvas. Beside this, the method "amVisible" is overridden to signalise that this detector is not used for simulation- -internal reasons, but is placed over the simulation by the user.

Definition at line 62 of file GUI_E2_ZS_CollectorOverLanes.h.


Public Types
typedef std::vector < MSE2Collector * >	CollectorCont
	Definition of a E2-collector storage.
typedef std::vector < GUI_E2_ZS_Collector * >	CollectorVector
Public Member Functions
virtual GUIDetectorWrapper *	buildDetectorWrapper (GUIGlObjectStorage &idStorage)
virtual GUIDetectorWrapper *	buildDetectorWrapper (GUIGlObjectStorage &idStorage, GUILaneWrapper &lane)
const std::string &	getID () const throw ()
	Returns this detector's id.
SUMOReal	getLength () const throw ()
	Returns this detector's length [m].
const std::string &	getStartLaneID () const throw ()
	Returns the id of the lane this detector starts at.
	GUI_E2_ZS_CollectorOverLanes (std::string id, DetectorUsage usage, MSLane *lane, SUMOReal startPos, SUMOTime haltingTimeThreshold, MetersPerSecond haltingSpeedThreshold, SUMOReal jamDistThreshold) throw ()
	Constructor.
void	init (MSLane *lane, SUMOReal detLength) throw ()
	Builds the consecutive E2-detectors.
	~GUI_E2_ZS_CollectorOverLanes () throw ()
	Destructor.
Virtual methods to implement by derived classes
virtual void	reset ()
	Resets collected values.
Methods inherited from MSDetectorFileOutput.
void	writeXMLDetectorProlog (OutputDevice &dev) const throw (IOError)
	Opens the XML-output using "detector" as root element.
void	writeXMLOutput (OutputDevice &dev, SUMOTime startTime, SUMOTime stopTime) throw (IOError)
	Writes collected values into the given stream.
Protected Types
typedef std::vector < MSE2Collector * >	DetectorVector
	Definition of a detector storage.
typedef std::vector < DetectorVector >	DetectorVectorVector
	Definition of a storage for detector vectors.
typedef std::vector< SUMOReal >	DoubleVector
	Definition of a SUMOReal storage.
typedef std::map< MSLane , MSE2Collector >	LaneDetMap
	Definition of a map from a lane to the detector lying on it.
typedef std::vector< MSLane * >	LaneVector
	Definition of a lane storage.
typedef std::vector< LaneVector >	LaneVectorVector
	Definition of a storage for lane vectors.
typedef DoubleVector	LengthVector
	Definition of a storage for SUMOReal vectors.
Protected Member Functions
MSE2Collector *	buildCollector (size_t c, size_t r, MSLane *l, SUMOReal start, SUMOReal end) throw ()
	Builds a single collector.
void	extendTo (SUMOReal length) throw ()
	This method extends the current length up to the given.
std::vector< MSLane * >	getLanePredeccessorLanes (MSLane *l) throw ()
	Returns the list of lanes predecessing the given one.
std::string	makeID (const std::string &baseID, size_t c, size_t r) const throw ()
	Builds an id for one of the E2-collectors this detector uses.
Protected Attributes
MetersPerSecond	haltingSpeedThresholdM
	Describes how slow a vehicle must be before being assigned to a jam.
SUMOTime	haltingTimeThresholdM
	Describes how long a vehicle shall stay before being assigned to a jam.
SUMOReal	jamDistThresholdM
	Describes how long a jam must be before being recognized.
LaneDetMap	myAlreadyBuild
	Storage for detectors which already have been build for a single lane.
DetectorVectorVector	myDetectorCombinations
	Storage for detector combinations.
std::string	myID
	The id of this detector.
LaneVectorVector	myLaneCombinations
	Storage for lane combinations.
SUMOReal	myLength
	The length of the collector.
LengthVector	myLengths
	Storage for length combinations.
std::string	myStartLaneID
	The id of the lane this detector starts at.
DetectorUsage	myUsage
	Information about how this detector is used.
SUMOReal	startPosM
	The position the collector starts at.
Data Structures
class	MyWrapper

Member Typedef Documentation

typedef std::vector< MSE2Collector* > MS_E2_ZS_CollectorOverLanes::CollectorCont [inherited]

Definition of a E2-collector storage.

Definition at line 58 of file MS_E2_ZS_CollectorOverLanes.h.

typedef std::vector<GUI_E2_ZS_Collector*> GUI_E2_ZS_CollectorOverLanes::CollectorVector

Definition at line 64 of file GUI_E2_ZS_CollectorOverLanes.h.

typedef std::vector<MSE2Collector*> MS_E2_ZS_CollectorOverLanes::DetectorVector [protected, inherited]

Definition of a detector storage.

Definition at line 208 of file MS_E2_ZS_CollectorOverLanes.h.

typedef std::vector<DetectorVector> MS_E2_ZS_CollectorOverLanes::DetectorVectorVector [protected, inherited]

Definition of a storage for detector vectors.

Definition at line 211 of file MS_E2_ZS_CollectorOverLanes.h.

typedef std::vector<SUMOReal> MS_E2_ZS_CollectorOverLanes::DoubleVector [protected, inherited]

Definition of a SUMOReal storage.

Definition at line 214 of file MS_E2_ZS_CollectorOverLanes.h.

typedef std::map<MSLane*, MSE2Collector*> MS_E2_ZS_CollectorOverLanes::LaneDetMap [protected, inherited]

Definition of a map from a lane to the detector lying on it.

Definition at line 245 of file MS_E2_ZS_CollectorOverLanes.h.

typedef std::vector<MSLane*> MS_E2_ZS_CollectorOverLanes::LaneVector [protected, inherited]

Definition of a lane storage.

Definition at line 202 of file MS_E2_ZS_CollectorOverLanes.h.

typedef std::vector<LaneVector> MS_E2_ZS_CollectorOverLanes::LaneVectorVector [protected, inherited]

Definition of a storage for lane vectors.

Definition at line 205 of file MS_E2_ZS_CollectorOverLanes.h.

typedef DoubleVector MS_E2_ZS_CollectorOverLanes::LengthVector [protected, inherited]

Definition of a storage for SUMOReal vectors.

Definition at line 217 of file MS_E2_ZS_CollectorOverLanes.h.

Constructor & Destructor Documentation

GUI_E2_ZS_CollectorOverLanes::GUI_E2_ZS_CollectorOverLanes	(	std::string	id,
		DetectorUsage	usage,
		MSLane *	lane,
		SUMOReal	startPos,
		SUMOTime	haltingTimeThreshold,
		MetersPerSecond	haltingSpeedThreshold,
		SUMOReal	jamDistThreshold
	)			throw ()

Constructor.

Definition at line 57 of file GUI_E2_ZS_CollectorOverLanes.cpp.

00062         : MS_E2_ZS_CollectorOverLanes(id, usage, lane, startPos,
00063                                       haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold) {}

GUI_E2_ZS_CollectorOverLanes::~GUI_E2_ZS_CollectorOverLanes ( ) throw ()

Destructor.

Definition at line 67 of file GUI_E2_ZS_CollectorOverLanes.cpp.

00067 {}

Member Function Documentation

MSE2Collector * GUI_E2_ZS_CollectorOverLanes::buildCollector	(	size_t	c,
		size_t	r,
		MSLane *	l,
		SUMOReal	start,
		SUMOReal	end
	)			throw () `[protected, virtual]`

Builds a single collector.

Parameters:

`[in]`	c	!!!
`[in]`	r	!!!
`[in]`	start	!!!
`[in]`	end	!!!

Todo:: Describe!

Reimplemented from MS_E2_ZS_CollectorOverLanes.

Definition at line 84 of file GUI_E2_ZS_CollectorOverLanes.cpp.

References MS_E2_ZS_CollectorOverLanes::getLength(), MS_E2_ZS_CollectorOverLanes::haltingSpeedThresholdM, MS_E2_ZS_CollectorOverLanes::haltingTimeThresholdM, MS_E2_ZS_CollectorOverLanes::jamDistThresholdM, MS_E2_ZS_CollectorOverLanes::makeID(), MS_E2_ZS_CollectorOverLanes::myID, MS_E2_ZS_CollectorOverLanes::myUsage, and SUMOReal.

00085                                               {
00086     std::string id = makeID(myID, c, r);
00087     if (start+end<l->getLength()) {
00088         start = l->getLength() - end - (SUMOReal) 0.1;
00089     }
00090     return new GUI_E2_ZS_Collector(id, myUsage,
00091                                    l, start, end, haltingTimeThresholdM,
00092                                    haltingSpeedThresholdM, jamDistThresholdM);
00093 }

GUIDetectorWrapper * GUI_E2_ZS_CollectorOverLanes::buildDetectorWrapper ( GUIGlObjectStorage & idStorage ) [virtual]

Definition at line 78 of file GUI_E2_ZS_CollectorOverLanes.cpp.

References MS_E2_ZS_CollectorOverLanes::myAlreadyBuild.

00078                                                                                 {
00079     return new MyWrapper(*this, idStorage, myAlreadyBuild);
00080 }

GUIDetectorWrapper * GUI_E2_ZS_CollectorOverLanes::buildDetectorWrapper	(	GUIGlObjectStorage &	idStorage,
		GUILaneWrapper &	lane
	)			`[virtual]`

Definition at line 71 of file GUI_E2_ZS_CollectorOverLanes.cpp.

00072                           {
00073     throw 1;
00074 }

void MS_E2_ZS_CollectorOverLanes::extendTo ( SUMOReal length ) throw () [protected, inherited]

This method extends the current length up to the given.

This method is called consecutively until all paths have the desired length

Parameters:

[in] length !!!

Todo:: Describe length's usage

Definition at line 80 of file MS_E2_ZS_CollectorOverLanes.cpp.

References MS_E2_ZS_CollectorOverLanes::buildCollector(), MSLane::getEdge(), MS_E2_ZS_CollectorOverLanes::getLanePredeccessorLanes(), MSEdge::getLanes(), MSLane::getLength(), MS_E2_ZS_CollectorOverLanes::myAlreadyBuild, MS_E2_ZS_CollectorOverLanes::myDetectorCombinations, MS_E2_ZS_CollectorOverLanes::myLaneCombinations, MS_E2_ZS_CollectorOverLanes::myLengths, and SUMOReal.

00080                                                              {
00081     bool done = false;
00082     while (!done) {
00083         done = true;
00084         LengthVector::iterator leni = myLengths.begin();
00085         LaneVectorVector::iterator lanei = myLaneCombinations.begin();
00086         DetectorVectorVector::iterator deti = myDetectorCombinations.begin();
00087         for (; leni!=myLengths.end(); leni++, lanei++, deti++) {
00088             if ((*leni)<length) {
00089                 done = false;
00090                 // copy current values
00091                 LaneVector lv = *lanei;
00092                 DetectorVector dv = *deti;
00093                 SUMOReal clength = *leni;
00094                 assert(lv.size()>0);
00095                 assert(dv.size()>0);
00096                 // erase previous elements
00097                 assert(leni!=myLengths.end());
00098                 myLengths.erase(leni);
00099                 myLaneCombinations.erase(lanei);
00100                 myDetectorCombinations.erase(deti);
00101                 // get the lane to look before
00102                 MSLane *toExtend = lv.back();
00103                 // and her predecessors
00104                 std::vector<MSLane*> predeccessors = getLanePredeccessorLanes(toExtend);
00105                 if (predeccessors.size()==0) {
00106                     int off = 1;
00107                     MSEdge &e = toExtend->getEdge();
00108                     const std::vector<MSLane*> &lanes = e.getLanes();
00109                     int idx = (int) distance(lanes.begin(), find(lanes.begin(), lanes.end(), toExtend));
00110                     while (predeccessors.size()==0) {
00111                         if (idx-off>=0) {
00112                             MSLane *tryMe = lanes[idx-off];
00113                             predeccessors = getLanePredeccessorLanes(tryMe);
00114                         }
00115                         if (predeccessors.size()==0&&idx+off<(int) lanes.size()) {
00116                             MSLane *tryMe = lanes[idx+off];
00117                             predeccessors = getLanePredeccessorLanes(tryMe);
00118                         }
00119                         off++;
00120                     }
00121                 }
00122 
00123                 /*                LaneContinuations::const_iterator conts =
00124                                     laneContinuations.find(toExtend->id());
00125                                 assert(conts!=laneContinuations.end());
00126                                 const std::vector<std::string> &predeccessors =
00127                                     (*conts).second;*/
00128                 // go through the predeccessors and extend the detector
00129                 for (std::vector<MSLane*>::const_iterator i=predeccessors.begin(); i!=predeccessors.end(); i++) {
00130                     // get the lane
00131                     MSLane *l = *i;
00132                     // compute detector length
00133                     SUMOReal lanelen = length - clength;
00134                     if (lanelen>l->getLength()) {
00135                         lanelen = l->getLength() - (SUMOReal) 0.2;
00136                     }
00137                     // build new info
00138                     LaneVector nlv = lv;
00139                     nlv.push_back(l);
00140                     DetectorVector ndv = dv;
00141                     MSE2Collector *coll = 0;
00142                     if (myAlreadyBuild.find(l)==myAlreadyBuild.end()) {
00143                         coll = buildCollector(0, 0, l, (SUMOReal) 0.1, lanelen);
00144                     } else {
00145                         coll = myAlreadyBuild.find(l)->second;
00146                     }
00147                     myAlreadyBuild[l] = coll;
00148                     ndv.push_back(coll);
00149                     // store new info
00150                     myLaneCombinations.push_back(nlv);
00151                     myDetectorCombinations.push_back(ndv);
00152                     myLengths.push_back(clength+lanelen);
00153                 }
00154                 // restart
00155                 leni = myLengths.end() - 1;
00156             }
00157         }
00158     }
00159 }

const std::string & MS_E2_ZS_CollectorOverLanes::getID ( ) const throw () [inherited]

Returns this detector's id.

Returns:: The id of this detector

Definition at line 254 of file MS_E2_ZS_CollectorOverLanes.cpp.

References MS_E2_ZS_CollectorOverLanes::myID.

Referenced by GUI_E2_ZS_CollectorOverLanes::MyWrapper::getMicrosimID().

00254                                                  {
00255     return myID;
00256 }

std::vector< MSLane * > MS_E2_ZS_CollectorOverLanes::getLanePredeccessorLanes ( MSLane * l ) throw () [protected, inherited]

Returns the list of lanes predecessing the given one.

Parameters:

[in] l The lane to return predecessors of

Returns:: List of lanes predecessing the given one

Definition at line 163 of file MS_E2_ZS_CollectorOverLanes.cpp.

References MSEdge::allowedLanes(), and SVC_UNKNOWN.

Referenced by MS_E2_ZS_CollectorOverLanes::extendTo().

00163                                                                        {
00164     std::string eid = l->getEdge().getID();
00165     // get predecessing edges
00166     const std::vector<MSEdge*> &predEdges = l->getEdge().getIncomingEdges();
00167     std::vector<MSLane*> ret;
00168     // find predecessing lanes
00169     std::vector<MSEdge*>::const_iterator i=predEdges.begin();
00170     for (; i!=predEdges.end(); ++i) {
00171         MSEdge *e = *i;
00172         assert(e!=0);
00173         typedef std::vector<MSLane*> LaneVector;
00174         const LaneVector *cl = e->allowedLanes(l->getEdge(), SVC_UNKNOWN);
00175         bool fastAbort = false;
00176         if (cl!=0) {
00177             for (LaneVector::const_iterator j=cl->begin(); !fastAbort&&j!=cl->end(); j++) {
00178                 const MSLinkCont &lc = (*j)->getLinkCont();
00179                 for (MSLinkCont::const_iterator k=lc.begin(); !fastAbort&&k!=lc.end(); k++) {
00180                     if ((*k)->getLane()==l) {
00181                         ret.push_back(*j);
00182                         fastAbort = true;
00183                     }
00184                 }
00185             }
00186         }
00187     }
00188     return ret;
00189 }

SUMOReal MS_E2_ZS_CollectorOverLanes::getLength ( ) const throw () [inline, inherited]

Returns this detector's length [m].

Returns:: This detector's length in meters

Definition at line 140 of file MS_E2_ZS_CollectorOverLanes.h.

References MS_E2_ZS_CollectorOverLanes::myLength.

Referenced by MS_E2_ZS_CollectorOverLanes::buildCollector(), buildCollector(), and GUI_E2_ZS_CollectorOverLanes::MyWrapper::getParameterWindow().

00140                                         {
00141         return myLength;
00142     }

const std::string & MS_E2_ZS_CollectorOverLanes::getStartLaneID ( ) const throw () [inherited]

Returns the id of the lane this detector starts at.

Returns:: The id of the lane this detector starts at

Todo:: Check whether this is needed

Definition at line 260 of file MS_E2_ZS_CollectorOverLanes.cpp.

References MS_E2_ZS_CollectorOverLanes::myStartLaneID.

00260                                                           {
00261     return myStartLaneID;
00262 }

void MS_E2_ZS_CollectorOverLanes::init	(	MSLane *	lane,
		SUMOReal	detLength
	)			throw () `[inherited]`

Builds the consecutive E2-detectors.

This is not done within the constructor to allow overriding of most functions but the building of detectors itself which in fact is depending on whether the normal or the gui-version is used

Parameters:

`[in]`	lane	The lane the detector starts at
`[in]`	startPos	Begin position of the detector

Definition at line 54 of file MS_E2_ZS_CollectorOverLanes.cpp.

References SUMOReal.

Referenced by NLDetectorBuilder::buildMultiLaneE2Det().

00054                                                                           {
00055     myLength = detLength;
00056     if (startPosM==0) {
00057         startPosM = (SUMOReal) 0.1;
00058     }
00059     SUMOReal length = lane->getLength() - startPosM - (SUMOReal) 0.1;
00060     SUMOReal dlength = detLength;
00061     if (length>dlength) {
00062         length = dlength;
00063     }
00064     myLengths.push_back(length);
00065     myLaneCombinations.push_back(LaneVector());
00066     myLaneCombinations[0].push_back(lane);
00067     myDetectorCombinations.push_back(DetectorVector());
00068     MSE2Collector *c =
00069         buildCollector(0, 0, lane, startPosM, length);
00070     myDetectorCombinations[0].push_back(c);
00071     myAlreadyBuild[lane] = c;
00072     extendTo(detLength);
00073 }

std::string MS_E2_ZS_CollectorOverLanes::makeID	(	const std::string &	baseID,
		size_t	c,
		size_t	r
	)			const throw () `[protected, inherited]`

Builds an id for one of the E2-collectors this detector uses.

Parameters:

`[in]`	baseID	The id of the parent detector
`[in]`	c	!!!
`[in]`	r	!!!

Todo:: Describe!

Definition at line 232 of file MS_E2_ZS_CollectorOverLanes.cpp.

References DU_SUMO_INTERNAL, DU_TL_CONTROL, DU_USER_DEFINED, and MS_E2_ZS_CollectorOverLanes::myUsage.

Referenced by MS_E2_ZS_CollectorOverLanes::buildCollector(), and buildCollector().

00233                                                                                   {
00234     std::string add;
00235     switch (myUsage) {
00236     case DU_USER_DEFINED:
00237         add = "(u)";
00238         break;
00239     case DU_SUMO_INTERNAL:
00240         add = "(i)";
00241         break;
00242     case DU_TL_CONTROL:
00243         add = "(c)";
00244         break;
00245     default:
00246         break;
00247     }
00248     std::string ret =  baseID + add + toString<size_t>(bla++);
00249     return ret;
00250 }

virtual void MSDetectorFileOutput::reset ( ) [inline, virtual, inherited]

Resets collected values.

Please note that this is only a "hack" for coupled-tls-outputs.

See also:: Command_SaveTLCoupledLaneDet

Todo:: Reckeck/refactor

Reimplemented in MSE2Collector, MSE3Collector, and MSInductLoop.

Definition at line 97 of file MSDetectorFileOutput.h.

Referenced by Command_SaveTLCoupledLaneDet::execute().

00097 { }

void MS_E2_ZS_CollectorOverLanes::writeXMLDetectorProlog ( OutputDevice & dev ) const throw (IOError) [virtual, inherited]

Opens the XML-output using "detector" as root element.

Parameters:

[in] dev The output device to write the root into

See also:: MSDetectorFileOutput::writeXMLDetectorProlog

Todo:

What happens with the additional information if several detectors use the same output?

Exceptions:

IOError

If an error on writing occurs (!!! not yet implemented)

Implements MSDetectorFileOutput.

Definition at line 224 of file MS_E2_ZS_CollectorOverLanes.cpp.

00224                                                                                           {
00225     dev.writeXMLHeader("detector");
00226 }

void MS_E2_ZS_CollectorOverLanes::writeXMLOutput	(	OutputDevice &	dev,
		SUMOTime	startTime,
		SUMOTime	stopTime
	)			throw (IOError) `[virtual, inherited]`

Writes collected values into the given stream.

Parameters:

`[in]`	dev	The output device to write the data into
`[in]`	startTime	First time step the data were gathered
`[in]`	stopTime	Last time step the data were gathered

See also:: MSDetectorFileOutput::writeXMLOutput

Exceptions:

IOError

If an error on writing occurs (!!! not yet implemented)

Implements MSDetectorFileOutput.

Definition at line 206 of file MS_E2_ZS_CollectorOverLanes.cpp.

00207                                                               {
00208     /*
00209     dev<<"<interval begin=\""<<time2string(startTime)<<"\" end=\""<<
00210     time2string(stopTime)<<"\" "<<"id=\""<<myID<<"\" ";
00211     if (hasDetector(E2::QUEUE_LENGTH_AHEAD_OF_TRAFFIC_LIGHTS_IN_VEHICLES)) {
00212         dev<<"collQueueLengthAheadOfTrafficLightsInVehiclesMax=\"";
00213         dev<<toString(getCurrent(E2::QUEUE_LENGTH_AHEAD_OF_TRAFFIC_LIGHTS_IN_VEHICLES));
00214         dev<<"\" ";
00215         resetQueueLengthAheadOfTrafficLights();
00216     }
00217     myDetectorCombinations[0][0]->writeXMLOutput(dev, startTime, stopTime);
00218     dev<<"/>\n";
00219     */
00220 }