void NLDetectorBuilder::buildInstantInductLoop(const std::string& id, const std::string& lane, double pos, const std::string& device, bool friendlyPos, const std::string& vTypes) { // get and check the lane MSLane* clane = getLaneChecking(lane, SUMO_TAG_INSTANT_INDUCTION_LOOP, id); // get and check the position pos = getPositionChecking(pos, clane, friendlyPos, id); // build the loop MSDetectorFileOutput* loop = createInstantInductLoop(id, clane, pos, device, vTypes); // add the file output myNet.getDetectorControl().add(SUMO_TAG_INSTANT_INDUCTION_LOOP, loop); }
void NLDetectorBuilder::buildInductLoop(const std::string& id, const std::string& lane, double pos, SUMOTime splInterval, const std::string& device, bool friendlyPos, const std::string& vTypes) { checkSampleInterval(splInterval, SUMO_TAG_E1DETECTOR, id); // get and check the lane MSLane* clane = getLaneChecking(lane, SUMO_TAG_E1DETECTOR, id); // get and check the position pos = getPositionChecking(pos, clane, friendlyPos, id); // build the loop MSDetectorFileOutput* loop = createInductLoop(id, clane, pos, vTypes); // add the file output myNet.getDetectorControl().add(SUMO_TAG_INDUCTION_LOOP, loop, device, splInterval); }
void NLDetectorBuilder::buildInductLoop(const std::string& id, const std::string& lane, SUMOReal pos, int splInterval, const std::string& device, bool friendlyPos, bool splitByType) { checkSampleInterval(splInterval, SUMO_TAG_E1DETECTOR, id); // get and check the lane MSLane* clane = getLaneChecking(lane, SUMO_TAG_E1DETECTOR, id); if (!MSGlobals::gUseMesoSim) { // get and check the position pos = getPositionChecking(pos, clane, friendlyPos, id); // build the loop MSDetectorFileOutput* loop = createInductLoop(id, clane, pos, splitByType); // add the file output myNet.getDetectorControl().add(SUMO_TAG_INDUCTION_LOOP, loop, device, splInterval); } else { #ifdef HAVE_INTERNAL if (pos < 0) { pos = clane->getLength() + pos; } MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(clane->getEdge()); MESegment* prev = s; SUMOReal cpos = 0; while (cpos + prev->getLength() < pos && s != 0) { prev = s; cpos += s->getLength(); s = s->getNextSegment(); } SUMOReal rpos = pos - cpos; //-prev->getLength(); if (rpos > prev->getLength() || rpos < 0) { if (friendlyPos) { rpos = prev->getLength() - (SUMOReal) 0.1; } else { throw InvalidArgument("The position of detector '" + id + "' lies beyond the lane's '" + lane + "' length."); } } MEInductLoop* loop = createMEInductLoop(id, prev, rpos); myNet.getDetectorControl().add(SUMO_TAG_INDUCTION_LOOP, loop, device, splInterval); #endif } }
void NLDetectorBuilder::buildMsgDetector(const std::string &id, const std::string &lane, SUMOReal pos, int splInterval, const std::string &msg, OutputDevice& device, bool friendlyPos) throw(InvalidArgument) { if (splInterval<0) { throw InvalidArgument("Negative sampling frequency (in e4-detector '" + id + "')."); } if (splInterval==0) { throw InvalidArgument("Sampling frequency must not be zero (in e4-detector '" + id + "')."); } if (msg == "") { throw InvalidArgument("No Message given (in e4-detector '" + id + "')."); } MSLane *clane = getLaneChecking(lane, id); if (pos<0) { pos = clane->getLength() + pos; } pos = getPositionChecking(pos, clane, friendlyPos, id); MSMsgInductLoop *msgloop = createMsgInductLoop(id, msg, clane, pos); myNet.getDetectorControl().add(msgloop, device, splInterval); }
void NLDetectorBuilder::buildE2Detector(const std::string& id, const std::string& lane, SUMOReal pos, SUMOReal length, bool cont, int splInterval, const std::string& device, SUMOTime haltingTimeThreshold, SUMOReal haltingSpeedThreshold, SUMOReal jamDistThreshold, bool friendlyPos) { checkSampleInterval(splInterval, SUMO_TAG_E2DETECTOR, id); MSLane* clane = getLaneChecking(lane, SUMO_TAG_E2DETECTOR, id); // check whether the detector may lie over more than one lane MSDetectorFileOutput* det = 0; if (!cont) { convUncontE2PosLength(id, clane, pos, length, friendlyPos); det = buildSingleLaneE2Det(id, DU_USER_DEFINED, clane, pos, length, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold); myNet.getDetectorControl().add(SUMO_TAG_LANE_AREA_DETECTOR, det, device, splInterval); } else { convContE2PosLength(id, clane, pos, length, friendlyPos); det = buildMultiLaneE2Det(id, DU_USER_DEFINED, clane, pos, length, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold); myNet.getDetectorControl().add(SUMO_TAG_LANE_AREA_DETECTOR, det, device, splInterval); } }
void NLDetectorBuilder::buildE2Detector(const std::string &id, const std::string &lane, SUMOReal pos, SUMOReal length, bool cont, MSTLLogicControl::TLSLogicVariants &tlls, OutputDevice& device, SUMOTime haltingTimeThreshold, SUMOReal haltingSpeedThreshold, SUMOReal jamDistThreshold, bool friendlyPos) throw(InvalidArgument) { if (tlls.getActive()==0) { throw InvalidArgument("The detector '" + id + "' refers to the unknown lsa."); } MSLane *clane = getLaneChecking(lane, id); // check whether the detector may lie over more than one lane MSDetectorFileOutput *det = 0; if (!cont) { convUncontE2PosLength(id, clane, pos, length, friendlyPos); det = buildSingleLaneE2Det(id, DU_USER_DEFINED, clane, pos, length, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold); myNet.getDetectorControl().add( static_cast<MSE2Collector*>(det)); } else { convContE2PosLength(id, clane, pos, length, friendlyPos); det = buildMultiLaneE2Det(id, DU_USER_DEFINED, clane, pos, length, haltingTimeThreshold, haltingSpeedThreshold, jamDistThreshold); myNet.getDetectorControl().add( static_cast<MS_E2_ZS_CollectorOverLanes*>(det)); } // add the file output new Command_SaveTLCoupledDet(tlls, det, myNet.getCurrentTimeStep(), device); }
bool TraCIServerAPI_Simulation::commandDistanceRequest(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage, int commandId) { Position pos1; Position pos2; std::pair<const MSLane*, SUMOReal> roadPos1; std::pair<const MSLane*, SUMOReal> roadPos2; // read position 1 int posType = inputStorage.readUnsignedByte(); switch (posType) { case POSITION_ROADMAP: try { std::string roadID = inputStorage.readString(); roadPos1.second = inputStorage.readDouble(); roadPos1.first = getLaneChecking(roadID, inputStorage.readUnsignedByte(), roadPos1.second); pos1 = roadPos1.first->getShape().positionAtOffset(roadPos1.second); } catch (TraCIException& e) { server.writeStatusCmd(commandId, RTYPE_ERR, e.what()); return false; } break; case POSITION_2D: case POSITION_3D: { SUMOReal p1x = inputStorage.readDouble(); SUMOReal p1y = inputStorage.readDouble(); pos1.set(p1x, p1y); } if (posType == POSITION_3D) { inputStorage.readDouble(); // z value is ignored } roadPos1 = convertCartesianToRoadMap(pos1); break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Unknown position format used for distance request"); return false; } // read position 2 posType = inputStorage.readUnsignedByte(); switch (posType) { case POSITION_ROADMAP: try { std::string roadID = inputStorage.readString(); roadPos2.second = inputStorage.readDouble(); roadPos2.first = getLaneChecking(roadID, inputStorage.readUnsignedByte(), roadPos2.second); pos2 = roadPos2.first->getShape().positionAtOffset(roadPos2.second); } catch (TraCIException& e) { server.writeStatusCmd(commandId, RTYPE_ERR, e.what()); return false; } break; case POSITION_2D: case POSITION_3D: { SUMOReal p2x = inputStorage.readDouble(); SUMOReal p2y = inputStorage.readDouble(); pos2.set(p2x, p2y); } if (posType == POSITION_3D) { inputStorage.readDouble(); // z value is ignored } roadPos2 = convertCartesianToRoadMap(pos2); break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Unknown position format used for distance request"); return false; } // read distance type int distType = inputStorage.readUnsignedByte(); SUMOReal distance = 0.0; if (distType == REQUEST_DRIVINGDIST) { // compute driving distance if ((roadPos1.first == roadPos2.first) && (roadPos1.second <= roadPos2.second)) { // same edge distance = roadPos2.second - roadPos1.second; } else { MSEdgeVector newRoute; MSNet::getInstance()->getRouterTT().compute( &roadPos1.first->getEdge(), &roadPos2.first->getEdge(), 0, MSNet::getInstance()->getCurrentTimeStep(), newRoute); MSRoute route("", newRoute, false, 0, std::vector<SUMOVehicleParameter::Stop>()); distance = route.getDistanceBetween(roadPos1.second, roadPos2.second, &roadPos1.first->getEdge(), &roadPos2.first->getEdge()); } } else { // compute air distance (default) distance = pos1.distanceTo(pos2); } // write response command outputStorage.writeUnsignedByte(TYPE_DOUBLE); outputStorage.writeDouble(distance); return true; }
bool TraCIServerAPI_Simulation::commandPositionConversion(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage, int commandId) { std::pair<MSLane*, SUMOReal> roadPos; Position cartesianPos; Position geoPos; SUMOReal z = 0; // actual position type that will be converted int srcPosType = inputStorage.readUnsignedByte(); switch (srcPosType) { case POSITION_2D: case POSITION_3D: case POSITION_LON_LAT: case POSITION_LON_LAT_ALT: { SUMOReal x = inputStorage.readDouble(); SUMOReal y = inputStorage.readDouble(); if (srcPosType != POSITION_2D && srcPosType != POSITION_LON_LAT) { z = inputStorage.readDouble(); } geoPos.set(x, y); cartesianPos.set(x, y); if (srcPosType == POSITION_LON_LAT || srcPosType == POSITION_LON_LAT_ALT) { GeoConvHelper::getFinal().x2cartesian_const(cartesianPos); } else { GeoConvHelper::getFinal().cartesian2geo(geoPos); } } break; case POSITION_ROADMAP: { std::string roadID = inputStorage.readString(); SUMOReal pos = inputStorage.readDouble(); int laneIdx = inputStorage.readUnsignedByte(); try { // convert edge,offset,laneIdx to cartesian position cartesianPos = geoPos = getLaneChecking(roadID, laneIdx, pos)->getShape().positionAtOffset(pos); z = cartesianPos.z(); GeoConvHelper::getFinal().cartesian2geo(geoPos); } catch (TraCIException& e) { server.writeStatusCmd(commandId, RTYPE_ERR, e.what()); return false; } } break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Source position type not supported"); return false; } int destPosType = 0; if (!server.readTypeCheckingUnsignedByte(inputStorage, destPosType)) { server.writeStatusCmd(commandId, RTYPE_ERR, "Destination position type must be of type ubyte."); return false; } switch (destPosType) { case POSITION_ROADMAP: { // convert cartesion position to edge,offset,lane_index roadPos = convertCartesianToRoadMap(cartesianPos); // write result that is added to response msg outputStorage.writeUnsignedByte(POSITION_ROADMAP); outputStorage.writeString(roadPos.first->getEdge().getID()); outputStorage.writeDouble(roadPos.second); const std::vector<MSLane*> lanes = roadPos.first->getEdge().getLanes(); outputStorage.writeUnsignedByte((int)distance(lanes.begin(), find(lanes.begin(), lanes.end(), roadPos.first))); } break; case POSITION_2D: case POSITION_3D: case POSITION_LON_LAT: case POSITION_LON_LAT_ALT: outputStorage.writeUnsignedByte(destPosType); if (destPosType == POSITION_LON_LAT || destPosType == POSITION_LON_LAT_ALT) { outputStorage.writeDouble(geoPos.x()); outputStorage.writeDouble(geoPos.y()); } else { outputStorage.writeDouble(cartesianPos.x()); outputStorage.writeDouble(cartesianPos.y()); } if (destPosType != POSITION_2D && destPosType != POSITION_LON_LAT) { outputStorage.writeDouble(z); } break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Destination position type not supported"); return false; } return true; }