task main()
{
StartTask(listenToBluetooth);
moveToTop();
moveToOrigin();
wait1Msec(500);
while(true){wait10Msec(100);}
}
// Go through the vector, set bricks, and move conveyor after each row
void writeLetter(char* letter, int size)
{
for(int i=0; i<size; i++)
{
// move the conveyor
if (i!=0 && i%5==0){
sendMessageWithParm(CONVEYOR, CONVEYOR_MOVE, 1);
PlaySound(soundBeepBeep);
wait1Msec(500);
}
if (letter[i]=='1'){
sendMessageWithParm(WEBSERVER, STT_PRINTING, i);
setBrick(i%5,0);
// Calibrate after each brick placement
moveToOrigin();
}
}
}
// Pick a brick from warehouse and plug it in
void setBrick(int i, int j)
{
// how deep should it go
const float down = 3;
driveNipple(5.2,30,MoveMotor);
// If no brick wait 2,5 sec and check again
while (!haveBrick()){
// send to server error message
sendMessageWithParm(WEBSERVER, ERR_NO_BRICKS, 0);
wait1Msec(2500);
}
driveNipple(5.2,-30,MoveMotor);
// loading
driveGear(down,15,LiftMotor, LiftGear);
wait1Msec(500);
driveGear(down,-30,LiftMotor, LiftGear);
wait1Msec(500);
moveToOrigin(); // calibrate
// move to plate
driveNipple(i+5 ,20,MoveMotor);
driveGear(0.8,10,MoveMotor, MoveGear);
//driveGear(1,-20,MoveMotor, MoveGear);
wait1Msec(500);
// printing
//driveGear(down,15,LiftMotor, LiftGear);
//wait1Msec(10);
plugInBrick(down);
wait1Msec(500);
driveGear(down,-30,LiftMotor, LiftGear);
wait1Msec(500);
//haveBrick();
}
void ArticulatedModel::preprocess(const Array<Instruction>& program) {
for (int i = 0; i < program.size(); ++i) {
const Instruction& instruction = program[i];
Part* partPtr = NULL;
switch (instruction.type) {
case Instruction::SCALE:
{
// Scale every pivot translation and every vertex position by the scale factor
float scaleFactor = instruction.arg;
scaleWholeModel(scaleFactor);
}
break;
case Instruction::MOVE_CENTER_TO_ORIGIN:
moveToOrigin(true);
break;
case Instruction::MOVE_BASE_TO_ORIGIN:
moveToOrigin(false);
break;
case Instruction::SET_MATERIAL:
{
bool keepLightMaps = true;
if (instruction.source.size() == 3) {
keepLightMaps = instruction.source[2];
}
UniversalMaterial::Specification specification(instruction.arg);
setMaterial(instruction.mesh, specification, keepLightMaps, instruction.source);
}
break;
case Instruction::SET_TWO_SIDED:
{
SetTwoSidedCallback callback(instruction.arg);
forEachMesh(instruction.mesh, callback, instruction.source);
}
break;
case Instruction::SET_CFRAME:
{
const CFrame cframe = instruction.arg;
if (instruction.part.isRoot()) {
for (int p = 0; p < m_rootArray.size(); ++p) {
m_rootArray[p]->cframe = cframe;
}
} else if (instruction.part.isAll()) {
for (int p = 0; p < m_partArray.size(); ++p) {
m_partArray[p]->cframe = cframe;
}
} else {
partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Part not found.");
partPtr->cframe = cframe;
}
}
break;
case Instruction::TRANSFORM_CFRAME:
{
const CFrame cframe = instruction.arg;
if (instruction.part.isRoot()) {
for (int p = 0; p < m_rootArray.size(); ++p) {
m_rootArray[p]->cframe = cframe * m_rootArray[p]->cframe;
}
} else if (instruction.part.isAll()) {
for (int p = 0; p < m_partArray.size(); ++p) {
m_partArray[p]->cframe = cframe * m_partArray[p]->cframe;
}
} else {
partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Part not found.");
partPtr->cframe = cframe * partPtr->cframe;
}
}
break;
case Instruction::TRANSFORM_GEOMETRY:
{
const Matrix4 transform(instruction.arg);
if (instruction.part.isRoot()) {
for (int p = 0; p < m_rootArray.size(); ++p) {
m_rootArray[p]->transformGeometry(dynamic_pointer_cast<ArticulatedModel>(shared_from_this()), transform);
}
} else if (instruction.part.isAll()) {
for (int p = 0; p < m_partArray.size(); ++p) {
m_partArray[p]->transformGeometry(dynamic_pointer_cast<ArticulatedModel>(shared_from_this()), transform);
}
} else {
partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Part not found.");
partPtr->transformGeometry(dynamic_pointer_cast<ArticulatedModel>(shared_from_this()), transform);
}
}
break;
case Instruction::RENAME_PART:
instruction.source.verify(! instruction.part.isAll() && ! instruction.part.isRoot(),
"The argument to renamePart() cannot be all() or root()");
partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Could not find part");
partPtr->name = instruction.arg.string();
break;
case Instruction::RENAME_MESH:
{
// Copy the array, since it may be modified by the callback
Array<Mesh*> meshArray;
getIdentifiedMeshes(instruction.mesh, meshArray);
instruction.source.verify(meshArray.size() == 1, "Must rename only one mesh");
instruction.source.verify(meshArray[0] != NULL, "Could not find mesh");
meshArray[0]->name = instruction.arg.string();
}
break;
case Instruction::ADD:
alwaysAssertM(false, "not implemented");
/*
partPtr = NULL;
if (! instruction.part.isNone()) {
partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Unrecognized parent part");
}
{
// Load the child part
shared_ptr<ArticulatedModel> m2 = ArticulatedModel::create(Specification(instruction.arg));
// Update part table and mesh table, and overwrite IDs
for (int p = 0; p < m2->m_partArray.size(); ++p) {
Part* part = m2->m_partArray[p];
const_cast<ID&>(part->id) = createID();
m_partTable.set(part->id, part);
for (int m = 0; m < part->m_meshArray.size(); ++m) {
Mesh* mesh = part->m_meshArray[m];
const_cast<ID&>(mesh->id) = createID();
m_meshTable.set(mesh->id, mesh);
}
}
// Steal all elements of the child and add them to this
if (partPtr == NULL) {
// Add as roots
m_rootArray.append(m2->m_rootArray);
} else {
// Reparent
partPtr->m_child.append(m2->m_rootArray);
for (int p = 0; p < m2->m_partArray.size(); ++p) {
if (m2->m_partArray[p]->isRoot()) {
m2->m_partArray[p]->m_parent = partPtr;
}
}
}
m_partArray.append(m2->m_partArray);
// Allow m2 to be garbage collected
}
*/
break;
case Instruction::REMOVE_MESH:
{
RemoveMeshCallback callback;
forEachMesh(instruction.mesh, callback, instruction.source);
}
break;
case Instruction::REVERSE_WINDING:
{
ReverseWindingCallback callback;
forEachMesh(instruction.mesh, callback, instruction.source);
}
break;
case Instruction::COPY_TEXCOORD0_TO_TEXCOORD1:
{
if (instruction.part.isRoot()) {
//TODO: implement
alwaysAssertM(false, "COPY_TEXCOORD0_TO_TEXCOORD1 currently implemented only for entire model");
/*for (int p = 0; p < m_rootArray.size(); ++p) {
m_rootArray[p]->cpuVertexArray.copyTexCoord0ToTexCoord1();
}*/
} else if (instruction.part.isAll()) {
for (int g = 0; g < m_geometryArray.size(); ++g) {
m_geometryArray[g]->cpuVertexArray.copyTexCoord0ToTexCoord1();
}
} else {
//TODO: implement
alwaysAssertM(false, "COPY_TEXCOORD0_TO_TEXCOORD1 currently implemented only for entire model");
/*partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Part not found.");
partPtr->cpuVertexArray.copyTexCoord0ToTexCoord1();*/
}
}
break;
case Instruction::OFFSET_AND_SCALE_TEXCOORD1:
{
const Point2& offset = instruction.arg;
const Point2& scale = instruction.source[2];
if (instruction.part.isRoot()) {
//TODO: implement
alwaysAssertM(false, "OFFSET_AND_SCALE_TEXCOORD1 currently implemented only for entire model");
/*for (int p = 0; p < m_rootArray.size(); ++p) {
m_rootArray[p]->cpuVertexArray.offsetAndScaleTexCoord1(offset, scale);
}*/
} else if (instruction.part.isAll()) {
for (int g = 0; g < m_geometryArray.size(); ++g) {
m_geometryArray[g]->cpuVertexArray.offsetAndScaleTexCoord1(offset, scale);
}
} else {
//TODO: implement
alwaysAssertM(false, "OFFSET_AND_SCALE_TEXCOORD1 currently implemented only for entire model");
/*partPtr = part(instruction.part);
instruction.source.verify(partPtr != NULL, "Part not found.");
partPtr->cpuVertexArray.offsetAndScaleTexCoord1(offset, scale);*/
}
}
break;
case Instruction::MERGE_ALL:
{
MeshMergeCallback merge(MeshMergeCriterion(instruction.arg));
forEachPart(merge);
}
break;
default:
alwaysAssertM(false, "Instruction not implemented");
}
}
}
void
NBNetBuilder::compute(OptionsCont& oc,
const std::set<std::string>& explicitTurnarounds,
bool removeElements) {
GeoConvHelper& geoConvHelper = GeoConvHelper::getProcessing();
const bool lefthand = oc.getBool("lefthand");
if (lefthand) {
mirrorX();
};
// MODIFYING THE SETS OF NODES AND EDGES
// Removes edges that are connecting the same node
long before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Removing self-loops");
myNodeCont.removeSelfLoops(myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
//
if (oc.exists("remove-edges.isolated") && oc.getBool("remove-edges.isolated")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Finding isolated roads");
myNodeCont.removeIsolatedRoads(myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
}
//
if (oc.exists("keep-edges.postload") && oc.getBool("keep-edges.postload")) {
if (oc.isSet("keep-edges.explicit") || oc.isSet("keep-edges.input-file")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Removing unwished edges");
myEdgeCont.removeUnwishedEdges(myDistrictCont);
PROGRESS_TIME_MESSAGE(before);
}
}
if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) {
// preliminary geometry computations to determine the length of edges
// This depends on turning directions and sorting of edge list
// in case junctions are joined geometry computations have to be repeated
// preliminary roundabout computations to avoid damaging roundabouts via junctions.join or ramps.guess
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false);
NBNodesEdgesSorter::sortNodesEdges(myNodeCont);
myEdgeCont.computeLaneShapes();
myNodeCont.computeNodeShapes();
myEdgeCont.computeEdgeShapes();
if (oc.getBool("roundabouts.guess")) {
myEdgeCont.guessRoundabouts();
}
const std::set<EdgeSet>& roundabouts = myEdgeCont.getRoundabouts();
for (std::set<EdgeSet>::const_iterator it_round = roundabouts.begin();
it_round != roundabouts.end(); ++it_round) {
std::vector<std::string> nodeIDs;
for (EdgeSet::const_iterator it_edge = it_round->begin(); it_edge != it_round->end(); ++it_edge) {
nodeIDs.push_back((*it_edge)->getToNode()->getID());
}
myNodeCont.addJoinExclusion(nodeIDs);
}
}
// join junctions (may create new "geometry"-nodes so it needs to come before removing these
if (oc.exists("junctions.join-exclude") && oc.isSet("junctions.join-exclude")) {
myNodeCont.addJoinExclusion(oc.getStringVector("junctions.join-exclude"));
}
unsigned int numJoined = myNodeCont.joinLoadedClusters(myDistrictCont, myEdgeCont, myTLLCont);
if (oc.getBool("junctions.join")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Joining junction clusters");
numJoined += myNodeCont.joinJunctions(oc.getFloat("junctions.join-dist"), myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
}
if (oc.getBool("junctions.join") || (oc.exists("ramps.guess") && oc.getBool("ramps.guess"))) {
// reset geometry to avoid influencing subsequent steps (ramps.guess)
myEdgeCont.computeLaneShapes();
}
if (numJoined > 0) {
// bit of a misnomer since we're already done
WRITE_MESSAGE(" Joined " + toString(numJoined) + " junction cluster(s).");
}
//
if (removeElements) {
unsigned int no = 0;
const bool removeGeometryNodes = oc.exists("geometry.remove") && oc.getBool("geometry.remove");
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Removing empty nodes" + std::string(removeGeometryNodes ? " and geometry nodes" : ""));
// removeUnwishedNodes needs turnDirections. @todo: try to call this less often
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false);
no = myNodeCont.removeUnwishedNodes(myDistrictCont, myEdgeCont, myTLLCont, removeGeometryNodes);
PROGRESS_TIME_MESSAGE(before);
WRITE_MESSAGE(" " + toString(no) + " nodes removed.");
}
// MOVE TO ORIGIN
// compute new boundary after network modifications have taken place
Boundary boundary;
for (std::map<std::string, NBNode*>::const_iterator it = myNodeCont.begin(); it != myNodeCont.end(); ++it) {
boundary.add(it->second->getPosition());
}
for (std::map<std::string, NBEdge*>::const_iterator it = myEdgeCont.begin(); it != myEdgeCont.end(); ++it) {
boundary.add(it->second->getGeometry().getBoxBoundary());
}
geoConvHelper.setConvBoundary(boundary);
if (!oc.getBool("offset.disable-normalization") && oc.isDefault("offset.x") && oc.isDefault("offset.y")) {
moveToOrigin(geoConvHelper, lefthand);
}
geoConvHelper.computeFinal(lefthand); // information needed for location element fixed at this point
if (oc.exists("geometry.min-dist") && oc.isSet("geometry.min-dist")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Reducing geometries");
myEdgeCont.reduceGeometries(oc.getFloat("geometry.min-dist"));
PROGRESS_TIME_MESSAGE(before);
}
// @note: removing geometry can create similar edges so joinSimilarEdges must come afterwards
// @note: likewise splitting can destroy similarities so joinSimilarEdges must come before
if (removeElements && oc.getBool("edges.join")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Joining similar edges");
myNodeCont.joinSimilarEdges(myDistrictCont, myEdgeCont, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
}
if (oc.getBool("opposites.guess")) {
PROGRESS_BEGIN_MESSAGE("guessing opposite direction edges");
myEdgeCont.guessOpposites();
PROGRESS_DONE_MESSAGE();
}
//
if (oc.exists("geometry.split") && oc.getBool("geometry.split")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Splitting geometry edges");
myEdgeCont.splitGeometry(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
}
// turning direction
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing turning directions");
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
// correct edge geometries to avoid overlap
myNodeCont.avoidOverlap();
// guess ramps
if ((oc.exists("ramps.guess") && oc.getBool("ramps.guess")) || (oc.exists("ramps.set") && oc.isSet("ramps.set"))) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Guessing and setting on-/off-ramps");
NBNodesEdgesSorter::sortNodesEdges(myNodeCont);
NBRampsComputer::computeRamps(*this, oc);
PROGRESS_TIME_MESSAGE(before);
}
// guess sidewalks
if (oc.getBool("sidewalks.guess") || oc.getBool("sidewalks.guess.from-permissions")) {
const int sidewalks = myEdgeCont.guessSidewalks(oc.getFloat("default.sidewalk-width"),
oc.getFloat("sidewalks.guess.min-speed"),
oc.getFloat("sidewalks.guess.max-speed"),
oc.getBool("sidewalks.guess.from-permissions"));
WRITE_MESSAGE("Guessed " + toString(sidewalks) + " sidewalks.");
}
// check whether any not previously setable connections may be set now
myEdgeCont.recheckPostProcessConnections();
// remap ids if wished
if (oc.getBool("numerical-ids")) {
int numChangedEdges = myEdgeCont.mapToNumericalIDs();
int numChangedNodes = myNodeCont.mapToNumericalIDs();
if (numChangedEdges + numChangedNodes > 0) {
WRITE_MESSAGE("Remapped " + toString(numChangedEdges) + " edge IDs and " + toString(numChangedNodes) + " node IDs.");
}
}
//
if (oc.exists("geometry.max-angle")) {
myEdgeCont.checkGeometries(
DEG2RAD(oc.getFloat("geometry.max-angle")),
oc.getFloat("geometry.min-radius"),
oc.getBool("geometry.min-radius.fix"));
}
// GEOMETRY COMPUTATION
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Sorting nodes' edges");
NBNodesEdgesSorter::sortNodesEdges(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
myEdgeCont.computeLaneShapes();
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing node shapes");
if (oc.exists("geometry.junction-mismatch-threshold")) {
myNodeCont.computeNodeShapes(oc.getFloat("geometry.junction-mismatch-threshold"));
} else {
myNodeCont.computeNodeShapes();
}
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing edge shapes");
myEdgeCont.computeEdgeShapes();
PROGRESS_TIME_MESSAGE(before);
// resort edges based on the node and edge shapes
NBNodesEdgesSorter::sortNodesEdges(myNodeCont, true);
NBTurningDirectionsComputer::computeTurnDirections(myNodeCont, false);
// APPLY SPEED MODIFICATIONS
if (oc.exists("speed.offset")) {
const SUMOReal speedOffset = oc.getFloat("speed.offset");
const SUMOReal speedFactor = oc.getFloat("speed.factor");
if (speedOffset != 0 || speedFactor != 1 || oc.isSet("speed.minimum")) {
const SUMOReal speedMin = oc.isSet("speed.minimum") ? oc.getFloat("speed.minimum") : -std::numeric_limits<SUMOReal>::infinity();
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Applying speed modifications");
for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
(*i).second->setSpeed(-1, MAX2((*i).second->getSpeed() * speedFactor + speedOffset, speedMin));
}
PROGRESS_TIME_MESSAGE(before);
}
}
// CONNECTIONS COMPUTATION
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing node types");
NBNodeTypeComputer::computeNodeTypes(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
//
bool haveCrossings = false;
if (oc.getBool("crossings.guess")) {
haveCrossings = true;
int crossings = 0;
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
crossings += (*i).second->guessCrossings();
}
WRITE_MESSAGE("Guessed " + toString(crossings) + " pedestrian crossings.");
}
if (!haveCrossings) {
// recheck whether we had crossings in the input
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
if (i->second->getCrossings().size() > 0) {
haveCrossings = true;
break;
}
}
}
if (oc.isDefault("no-internal-links") && !haveCrossings && myHaveLoadedNetworkWithoutInternalEdges) {
oc.set("no-internal-links", "true");
}
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing priorities");
NBEdgePriorityComputer::computeEdgePriorities(myNodeCont);
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing approached edges");
myEdgeCont.computeEdge2Edges(oc.getBool("no-left-connections"));
PROGRESS_TIME_MESSAGE(before);
//
if (oc.getBool("roundabouts.guess")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Guessing and setting roundabouts");
const int numGuessed = myEdgeCont.guessRoundabouts();
if (numGuessed > 0) {
WRITE_MESSAGE(" Guessed " + toString(numGuessed) + " roundabout(s).");
}
PROGRESS_TIME_MESSAGE(before);
}
myEdgeCont.markRoundabouts();
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing approaching lanes");
myEdgeCont.computeLanes2Edges();
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Dividing of lanes on approached lanes");
myNodeCont.computeLanes2Lanes();
myEdgeCont.sortOutgoingLanesConnections();
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Processing turnarounds");
if (!oc.getBool("no-turnarounds")) {
myEdgeCont.appendTurnarounds(oc.getBool("no-turnarounds.tls"));
} else {
myEdgeCont.appendTurnarounds(explicitTurnarounds, oc.getBool("no-turnarounds.tls"));
}
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Rechecking of lane endings");
myEdgeCont.recheckLanes();
PROGRESS_TIME_MESSAGE(before);
if (haveCrossings && !oc.getBool("no-internal-links")) {
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
i->second->buildCrossingsAndWalkingAreas();
}
}
// GUESS TLS POSITIONS
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Assigning nodes to traffic lights");
if (oc.isSet("tls.set")) {
std::vector<std::string> tlControlledNodes = oc.getStringVector("tls.set");
TrafficLightType type = SUMOXMLDefinitions::TrafficLightTypes.get(oc.getString("tls.default-type"));
for (std::vector<std::string>::const_iterator i = tlControlledNodes.begin(); i != tlControlledNodes.end(); ++i) {
NBNode* node = myNodeCont.retrieve(*i);
if (node == 0) {
WRITE_WARNING("Building a tl-logic for junction '" + *i + "' is not possible." + "\n The junction '" + *i + "' is not known.");
} else {
myNodeCont.setAsTLControlled(node, myTLLCont, type);
}
}
}
myNodeCont.guessTLs(oc, myTLLCont);
PROGRESS_TIME_MESSAGE(before);
//
if (oc.getBool("tls.join")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Joining traffic light nodes");
myNodeCont.joinTLS(myTLLCont, oc.getFloat("tls.join-dist"));
PROGRESS_TIME_MESSAGE(before);
}
// COMPUTING RIGHT-OF-WAY AND TRAFFIC LIGHT PROGRAMS
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing traffic light control information");
myTLLCont.setTLControllingInformation(myEdgeCont, myNodeCont);
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing node logics");
myNodeCont.computeLogics(myEdgeCont, oc);
PROGRESS_TIME_MESSAGE(before);
//
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Computing traffic light logics");
std::pair<unsigned int, unsigned int> numbers = myTLLCont.computeLogics(oc);
PROGRESS_TIME_MESSAGE(before);
std::string progCount = "";
if (numbers.first != numbers.second) {
progCount = "(" + toString(numbers.second) + " programs) ";
}
WRITE_MESSAGE(" " + toString(numbers.first) + " traffic light(s) " + progCount + "computed.");
//
if (oc.isSet("street-sign-output")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Generating street signs");
myEdgeCont.generateStreetSigns();
PROGRESS_TIME_MESSAGE(before);
}
// FINISHING INNER EDGES
if (!oc.getBool("no-internal-links")) {
before = SysUtils::getCurrentMillis();
PROGRESS_BEGIN_MESSAGE("Building inner edges");
for (std::map<std::string, NBEdge*>::const_iterator i = myEdgeCont.begin(); i != myEdgeCont.end(); ++i) {
(*i).second->sortOutgoingConnectionsByIndex();
}
// walking areas shall only be built if crossings are wished as well
for (std::map<std::string, NBNode*>::const_iterator i = myNodeCont.begin(); i != myNodeCont.end(); ++i) {
(*i).second->buildInnerEdges();
}
PROGRESS_TIME_MESSAGE(before);
}
if (lefthand) {
mirrorX();
};
// report
WRITE_MESSAGE("-----------------------------------------------------");
WRITE_MESSAGE("Summary:");
myNodeCont.printBuiltNodesStatistics();
WRITE_MESSAGE(" Network boundaries:");
WRITE_MESSAGE(" Original boundary : " + toString(geoConvHelper.getOrigBoundary()));
WRITE_MESSAGE(" Applied offset : " + toString(geoConvHelper.getOffsetBase()));
WRITE_MESSAGE(" Converted boundary : " + toString(geoConvHelper.getConvBoundary()));
WRITE_MESSAGE("-----------------------------------------------------");
NBRequest::reportWarnings();
// report on very large networks
if (MAX2(geoConvHelper.getConvBoundary().xmax(), geoConvHelper.getConvBoundary().ymax()) > 1000000 ||
MIN2(geoConvHelper.getConvBoundary().xmin(), geoConvHelper.getConvBoundary().ymin()) < -1000000) {
WRITE_WARNING("Network contains very large coordinates and will probably flicker in the GUI. Check for outlying nodes and make sure the network is shifted to the coordinate origin");
}
}
