void DescriptionFactory::Run(const SearchEngineT &sEngine, const unsigned zoomLevel, const unsigned duration) { if(0 == pathDescription.size()) return; // unsigned entireLength = 0; /** starts at index 1 */ pathDescription[0].length = 0; for(unsigned i = 1; i < pathDescription.size(); ++i) { pathDescription[i].length = ApproximateDistance(pathDescription[i-1].location, pathDescription[i].location); } unsigned lengthOfSegment = 0; unsigned durationOfSegment = 0; unsigned indexOfSegmentBegin = 0; std::string string0 = sEngine.GetEscapedNameForNameID(pathDescription[0].nameID); std::string string1; /*Simplify turn instructions Input : 10. Turn left on B 36 for 20 km 11. Continue on B 35; B 36 for 2 km 12. Continue on B 36 for 13 km becomes: 10. Turn left on B 36 for 35 km */ unsigned lastTurn = 0; for(unsigned i = 1; i < pathDescription.size(); ++i) { string1 = sEngine.GetEscapedNameForNameID(pathDescription[i].nameID); if(TurnInstructionsClass::GoStraight == pathDescription[i].turnInstruction) { if(std::string::npos != string0.find(string1+";") || std::string::npos != string0.find(";"+string1) || std::string::npos != string0.find(string1+" ;") || std::string::npos != string0.find("; "+string1)){ // INFO("->next correct: " << string0 << " contains " << string1); for(; lastTurn != i; ++lastTurn) pathDescription[lastTurn].nameID = pathDescription[i].nameID; pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn; } else if(std::string::npos != string1.find(string0+";") || std::string::npos != string1.find(";"+string0) || std::string::npos != string1.find(string0+" ;")|| std::string::npos != string1.find("; "+string0)) { // INFO("->prev correct: " << string1 << " contains " << string0); pathDescription[i].nameID = pathDescription[i-1].nameID; pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn; } } if (TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) { lastTurn = i; } string0 = string1; } for(unsigned i = 1; i < pathDescription.size(); ++i) { entireLength += pathDescription[i].length; lengthOfSegment += pathDescription[i].length; durationOfSegment += pathDescription[i].duration; pathDescription[indexOfSegmentBegin].length = lengthOfSegment; pathDescription[indexOfSegmentBegin].duration = durationOfSegment; if(TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) { //INFO("Turn after " << lengthOfSegment << "m into way with name id " << segment.nameID); assert(pathDescription[i].necessary); lengthOfSegment = 0; durationOfSegment = 0; indexOfSegmentBegin = i; } } // INFO("#segs: " << pathDescription.size()); //Post-processing to remove empty or nearly empty path segments if(0 == pathDescription.back().length) { // INFO("#segs: " << pathDescription.size() << ", last ratio: " << targetPhantom.ratio << ", length: " << pathDescription.back().length); if(pathDescription.size() > 2){ pathDescription.pop_back(); pathDescription.back().necessary = true; pathDescription.back().turnInstruction = TurnInstructions.NoTurn; targetPhantom.nodeBasedEdgeNameID = (pathDescription.end()-2)->nameID; // INFO("Deleting last turn instruction"); } } else { pathDescription[indexOfSegmentBegin].duration *= (1.-targetPhantom.ratio); } if(0 == pathDescription[0].length) { if(pathDescription.size() > 2) { pathDescription.erase(pathDescription.begin()); pathDescription[0].turnInstruction = TurnInstructions.HeadOn; pathDescription[0].necessary = true; startPhantom.nodeBasedEdgeNameID = pathDescription[0].nameID; // INFO("Deleting first turn instruction, ratio: " << startPhantom.ratio << ", length: " << pathDescription[0].length); } } else { pathDescription[0].duration *= startPhantom.ratio; } //Generalize poly line dp.Run(pathDescription, zoomLevel); //fix what needs to be fixed else for(unsigned i = 0; i < pathDescription.size()-1 && pathDescription.size() >= 2; ++i){ if(pathDescription[i].necessary) { int angle = 100*GetAzimuth(pathDescription[i].location, pathDescription[i+1].location); pathDescription[i].bearing = angle/100.; } } // BuildRouteSummary(entireLength, duration); return; }
void ExtractionContainers::PrepareData(const std::string & outputFileName, const std::string restrictionsFileName, const unsigned amountOfRAM) { try { unsigned usedNodeCounter = 0; unsigned usedEdgeCounter = 0; double time = get_timestamp(); boost::uint64_t memory_to_use = static_cast<boost::uint64_t>(amountOfRAM) * 1024 * 1024 * 1024; std::cout << "[extractor] Sorting used nodes ... " << std::flush; stxxl::sort(usedNodeIDs.begin(), usedNodeIDs.end(), Cmp(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Erasing duplicate nodes ... " << std::flush; stxxl::vector<NodeID>::iterator NewEnd = std::unique ( usedNodeIDs.begin(),usedNodeIDs.end() ) ; usedNodeIDs.resize ( NewEnd - usedNodeIDs.begin() ); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Sorting all nodes ... " << std::flush; stxxl::sort(allNodes.begin(), allNodes.end(), CmpNodeByID(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Sorting used ways ... " << std::flush; stxxl::sort(wayStartEndVector.begin(), wayStartEndVector.end(), CmpWayByID(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] Sorting restrctns. by from... " << std::flush; stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByFrom(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] Fixing restriction starts ... " << std::flush; STXXLRestrictionsVector::iterator restrictionsIT = restrictionsVector.begin(); STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = wayStartEndVector.begin(); while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) { if(wayStartAndEndEdgeIT->wayID < restrictionsIT->fromWay){ ++wayStartAndEndEdgeIT; continue; } if(wayStartAndEndEdgeIT->wayID > restrictionsIT->fromWay) { ++restrictionsIT; continue; } assert(wayStartAndEndEdgeIT->wayID == restrictionsIT->fromWay); NodeID viaNode = restrictionsIT->restriction.viaNode; if(wayStartAndEndEdgeIT->firstStart == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstTarget; } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstStart; } else if(wayStartAndEndEdgeIT->lastStart == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastTarget; } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastStart; } ++restrictionsIT; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Sorting restrctns. by to ... " << std::flush; stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByTo(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); unsigned usableRestrictionsCounter(0); std::cout << "[extractor] Fixing restriction ends ... " << std::flush; restrictionsIT = restrictionsVector.begin(); wayStartAndEndEdgeIT = wayStartEndVector.begin(); while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) { if(wayStartAndEndEdgeIT->wayID < restrictionsIT->toWay){ ++wayStartAndEndEdgeIT; continue; } if(wayStartAndEndEdgeIT->wayID > restrictionsIT->toWay) { ++restrictionsIT; continue; } NodeID viaNode = restrictionsIT->restriction.viaNode; if(wayStartAndEndEdgeIT->lastStart == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastTarget; } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastStart; } else if(wayStartAndEndEdgeIT->firstStart == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstTarget; } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstStart; } if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) { ++usableRestrictionsCounter; } ++restrictionsIT; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; INFO("usable restrictions: " << usableRestrictionsCounter ); //serialize restrictions std::ofstream restrictionsOutstream; restrictionsOutstream.open(restrictionsFileName.c_str(), std::ios::binary); restrictionsOutstream.write((char*)&usableRestrictionsCounter, sizeof(unsigned)); for(restrictionsIT = restrictionsVector.begin(); restrictionsIT != restrictionsVector.end(); ++restrictionsIT) { if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) { restrictionsOutstream.write((char *)&(restrictionsIT->restriction), sizeof(_Restriction)); } } restrictionsOutstream.close(); std::ofstream fout; fout.open(outputFileName.c_str(), std::ios::binary); fout.write((char*)&usedNodeCounter, sizeof(unsigned)); time = get_timestamp(); std::cout << "[extractor] Confirming/Writing used nodes ... " << std::flush; STXXLNodeVector::iterator nodesIT = allNodes.begin(); STXXLNodeIDVector::iterator usedNodeIDsIT = usedNodeIDs.begin(); while(usedNodeIDsIT != usedNodeIDs.end() && nodesIT != allNodes.end()) { if(*usedNodeIDsIT < nodesIT->id){ ++usedNodeIDsIT; continue; } if(*usedNodeIDsIT > nodesIT->id) { ++nodesIT; continue; } if(*usedNodeIDsIT == nodesIT->id) { fout.write((char*)&(*nodesIT), sizeof(_Node)); ++usedNodeCounter; ++usedNodeIDsIT; ++nodesIT; } } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] setting number of nodes ... " << std::flush; std::ios::pos_type positionInFile = fout.tellp(); fout.seekp(std::ios::beg); fout.write((char*)&usedNodeCounter, sizeof(unsigned)); fout.seekp(positionInFile); std::cout << "ok" << std::endl; time = get_timestamp(); // Sort edges by start. std::cout << "[extractor] Sorting edges by start ... " << std::flush; stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByStartID(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Setting start coords ... " << std::flush; fout.write((char*)&usedEdgeCounter, sizeof(unsigned)); // Traverse list of edges and nodes in parallel and set start coord nodesIT = allNodes.begin(); STXXLEdgeVector::iterator edgeIT = allEdges.begin(); while(edgeIT != allEdges.end() && nodesIT != allNodes.end()) { if(edgeIT->start < nodesIT->id){ ++edgeIT; continue; } if(edgeIT->start > nodesIT->id) { nodesIT++; continue; } if(edgeIT->start == nodesIT->id) { edgeIT->startCoord.lat = nodesIT->lat; edgeIT->startCoord.lon = nodesIT->lon; ++edgeIT; } } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); // Sort Edges by target std::cout << "[extractor] Sorting edges by target ... " << std::flush; stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByTargetID(), memory_to_use); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Setting target coords ... " << std::flush; // Traverse list of edges and nodes in parallel and set target coord nodesIT = allNodes.begin(); edgeIT = allEdges.begin(); while(edgeIT != allEdges.end() && nodesIT != allNodes.end()) { if(edgeIT->target < nodesIT->id){ ++edgeIT; continue; } if(edgeIT->target > nodesIT->id) { ++nodesIT; continue; } if(edgeIT->target == nodesIT->id) { if(edgeIT->startCoord.lat != INT_MIN && edgeIT->startCoord.lon != INT_MIN) { edgeIT->targetCoord.lat = nodesIT->lat; edgeIT->targetCoord.lon = nodesIT->lon; double distance = ApproximateDistance(edgeIT->startCoord.lat, edgeIT->startCoord.lon, nodesIT->lat, nodesIT->lon); assert(edgeIT->speed != -1); double weight = ( distance * 10. ) / (edgeIT->speed / 3.6); int intWeight = std::max(1, (int)std::floor((edgeIT->isDurationSet ? edgeIT->speed : weight)+.5) ); int intDist = std::max(1, (int)distance); short zero = 0; short one = 1; fout.write((char*)&edgeIT->start, sizeof(unsigned)); fout.write((char*)&edgeIT->target, sizeof(unsigned)); fout.write((char*)&intDist, sizeof(int)); switch(edgeIT->direction) { case ExtractionWay::oneway: fout.write((char*)&one, sizeof(short)); break; case ExtractionWay::bidirectional: fout.write((char*)&zero, sizeof(short)); break; case ExtractionWay::opposite: fout.write((char*)&one, sizeof(short)); break; default: std::cerr << "[error] edge with no direction: " << edgeIT->direction << std::endl; assert(false); break; } fout.write((char*)&intWeight, sizeof(int)); fout.write((char*)&edgeIT->nameID, sizeof(unsigned)); fout.write((char*)&edgeIT->isRoundabout, sizeof(bool)); fout.write((char*)&edgeIT->ignoreInGrid, sizeof(bool)); fout.write((char*)&edgeIT->isAccessRestricted, sizeof(bool)); fout.write((char*)&edgeIT->mode, sizeof(unsigned char)); } ++usedEdgeCounter; ++edgeIT; } } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] setting number of edges ... " << std::flush; std::cout << "[extractor] number of edges: " << usedEdgeCounter << std::flush; fout.seekp(positionInFile); fout.write((char*)&usedEdgeCounter, sizeof(unsigned)); fout.close(); std::cout << "ok" << std::endl; time = get_timestamp(); std::cout << "[extractor] writing street name index ... " << std::flush; std::string nameOutFileName = (outputFileName + ".names"); std::ofstream nameOutFile(nameOutFileName.c_str(), std::ios::binary); unsigned sizeOfNameIndex = nameVector.size(); nameOutFile.write((char *)&(sizeOfNameIndex), sizeof(unsigned)); BOOST_FOREACH(const std::string & str, nameVector) { unsigned lengthOfRawString = strlen(str.c_str()); nameOutFile.write((char *)&(lengthOfRawString), sizeof(unsigned)); nameOutFile.write(str.c_str(), lengthOfRawString); } nameOutFile.close(); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; // time = get_timestamp(); // cout << "[extractor] writing address list ... " << flush; // // adressFileName.append(".address"); // ofstream addressOutFile(adressFileName.c_str()); // for(STXXLAddressVector::iterator it = adressVector.begin(); it != adressVector.end(); it++) { // addressOutFile << it->node.id << "|" << it->node.lat << "|" << it->node.lon << "|" << it->city << "|" << it->street << "|" << it->housenumber << "|" << it->state << "|" << it->country << "\n"; // } // addressOutFile.close(); // cout << "ok, after " << get_timestamp() - time << "s" << endl; INFO("Processed " << usedNodeCounter << " nodes and " << usedEdgeCounter << " edges"); } catch ( const std::exception& e ) {
int main (int argc, char *argv[]) { if(argc <= 1) { cerr << "usage: " << endl << argv[0] << " <file.osm/.osm.bz2/.osm.pbf>" << endl; exit(-1); } cout << "[extractor] extracting data from input file " << argv[1] << endl; bool isPBF = false; string outputFileName(argv[1]); string restrictionsFileName(argv[1]); string::size_type pos = outputFileName.find(".osm.bz2"); if(pos==string::npos) { pos = outputFileName.find(".osm.pbf"); if(pos!=string::npos) { isPBF = true; } } if(pos!=string::npos) { outputFileName.replace(pos, 8, ".osrm"); restrictionsFileName.replace(pos, 8, ".osrm.restrictions"); } else { pos=outputFileName.find(".osm"); if(pos!=string::npos) { outputFileName.replace(pos, 5, ".osrm"); restrictionsFileName.replace(pos, 5, ".osrm.restrictions"); } else { outputFileName.append(".osrm"); restrictionsFileName.append(".osrm.restrictions"); } } string adressFileName(outputFileName); unsigned amountOfRAM = 1; unsigned installedRAM = GetPhysicalmemory(); if(installedRAM < 2048264) { cout << "[Warning] Machine has less than 2GB RAM." << endl; } if(testDataFile("extractor.ini")) { ExtractorConfiguration extractorConfig("extractor.ini"); unsigned memoryAmountFromFile = atoi(extractorConfig.GetParameter("Memory").c_str()); if( memoryAmountFromFile != 0 && memoryAmountFromFile <= installedRAM/(1024*1024*1024)) amountOfRAM = memoryAmountFromFile; cout << "[extractor] using " << amountOfRAM << " GB of RAM for buffers" << endl; } STXXLContainers externalMemory; unsigned usedNodeCounter = 0; unsigned usedEdgeCounter = 0; StringMap * stringMap = new StringMap(); Settings settings; settings.speedProfile.names.insert(settings.speedProfile.names.begin(), names, names+14); settings.speedProfile.speed.insert(settings.speedProfile.speed.begin(), speeds, speeds+14); double time = get_timestamp(); stringMap->set_empty_key(GetRandomString()); stringMap->insert(make_pair("", 0)); extractCallBacks = new ExtractorCallbacks(&externalMemory, settings, stringMap); BaseParser<_Node, _RawRestrictionContainer, _Way> * parser; if(isPBF) { parser = new PBFParser(argv[1]); } else { parser = new XMLParser(argv[1]); } parser->RegisterCallbacks(&nodeFunction, &restrictionFunction, &wayFunction, &adressFunction); if(parser->Init()) { parser->Parse(); } else { cerr << "[error] parser not initialized!" << endl; exit(-1); } delete parser; try { // INFO("raw no. of names: " << externalMemory.nameVector.size()); // INFO("raw no. of nodes: " << externalMemory.allNodes.size()); // INFO("no. of used nodes: " << externalMemory.usedNodeIDs.size()); // INFO("raw no. of edges: " << externalMemory.allEdges.size()); // INFO("raw no. of ways: " << externalMemory.wayStartEndVector.size()); // INFO("raw no. of addresses: " << externalMemory.adressVector.size()); // INFO("raw no. of restrictions: " << externalMemory.restrictionsVector.size()); cout << "[extractor] parsing finished after " << get_timestamp() - time << "seconds" << endl; time = get_timestamp(); uint64_t memory_to_use = static_cast<uint64_t>(amountOfRAM) * 1024 * 1024 * 1024; cout << "[extractor] Sorting used nodes ... " << flush; stxxl::sort(externalMemory.usedNodeIDs.begin(), externalMemory.usedNodeIDs.end(), Cmp(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] Erasing duplicate nodes ... " << flush; stxxl::vector<NodeID>::iterator NewEnd = unique ( externalMemory.usedNodeIDs.begin(),externalMemory.usedNodeIDs.end() ) ; externalMemory.usedNodeIDs.resize ( NewEnd - externalMemory.usedNodeIDs.begin() ); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] Sorting all nodes ... " << flush; stxxl::sort(externalMemory.allNodes.begin(), externalMemory.allNodes.end(), CmpNodeByID(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] Sorting used ways ... " << flush; stxxl::sort(externalMemory.wayStartEndVector.begin(), externalMemory.wayStartEndVector.end(), CmpWayStartAndEnd(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; cout << "[extractor] Sorting restrctns. by from... " << flush; stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionByFrom(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; cout << "[extractor] Fixing restriction starts ... " << flush; STXXLRestrictionsVector::iterator restrictionsIT = externalMemory.restrictionsVector.begin(); STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = externalMemory.wayStartEndVector.begin(); while(wayStartAndEndEdgeIT != externalMemory.wayStartEndVector.end() && restrictionsIT != externalMemory.restrictionsVector.end()) { if(wayStartAndEndEdgeIT->wayID < restrictionsIT->fromWay){ wayStartAndEndEdgeIT++; continue; } if(wayStartAndEndEdgeIT->wayID > restrictionsIT->fromWay) { restrictionsIT++; continue; } assert(wayStartAndEndEdgeIT->wayID == restrictionsIT->fromWay); NodeID viaNode = restrictionsIT->restriction.viaNode; if(wayStartAndEndEdgeIT->firstStart == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstTarget; } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstStart; } else if(wayStartAndEndEdgeIT->lastStart == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastTarget; } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) { restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastStart; } restrictionsIT++; } cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] Sorting restrctns. by to ... " << flush; stxxl::sort(externalMemory.restrictionsVector.begin(), externalMemory.restrictionsVector.end(), CmpRestrictionByTo(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); unsigned usableRestrictionsCounter(0); cout << "[extractor] Fixing restriction ends ... " << flush; restrictionsIT = externalMemory.restrictionsVector.begin(); wayStartAndEndEdgeIT = externalMemory.wayStartEndVector.begin(); while(wayStartAndEndEdgeIT != externalMemory.wayStartEndVector.end() && restrictionsIT != externalMemory.restrictionsVector.end()) { if(wayStartAndEndEdgeIT->wayID < restrictionsIT->toWay){ wayStartAndEndEdgeIT++; continue; } if(wayStartAndEndEdgeIT->wayID > restrictionsIT->toWay) { restrictionsIT++; continue; } NodeID viaNode = restrictionsIT->restriction.viaNode; if(wayStartAndEndEdgeIT->lastStart == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastTarget; } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastStart; } else if(wayStartAndEndEdgeIT->firstStart == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstTarget; } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) { restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstStart; } if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) { usableRestrictionsCounter++; } restrictionsIT++; } cout << "ok, after " << get_timestamp() - time << "s" << endl; //serialize restrictions ofstream restrictionsOutstream; restrictionsOutstream.open(restrictionsFileName.c_str(), ios::binary); restrictionsOutstream.write((char*)&usableRestrictionsCounter, sizeof(unsigned)); for(restrictionsIT = externalMemory.restrictionsVector.begin(); restrictionsIT != externalMemory.restrictionsVector.end(); restrictionsIT++) { if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) { restrictionsOutstream.write((char *)&(restrictionsIT->restriction), sizeof(_Restriction)); } } restrictionsOutstream.close(); ofstream fout; fout.open(outputFileName.c_str(), ios::binary); fout.write((char*)&usedNodeCounter, sizeof(unsigned)); time = get_timestamp(); cout << "[extractor] Confirming used nodes ... " << flush; STXXLNodeVector::iterator nodesIT = externalMemory.allNodes.begin(); STXXLNodeIDVector::iterator usedNodeIDsIT = externalMemory.usedNodeIDs.begin(); while(usedNodeIDsIT != externalMemory.usedNodeIDs.end() && nodesIT != externalMemory.allNodes.end()) { if(*usedNodeIDsIT < nodesIT->id){ usedNodeIDsIT++; continue; } if(*usedNodeIDsIT > nodesIT->id) { nodesIT++; continue; } if(*usedNodeIDsIT == nodesIT->id) { fout.write((char*)&(nodesIT->id), sizeof(unsigned)); fout.write((char*)&(nodesIT->lon), sizeof(int)); fout.write((char*)&(nodesIT->lat), sizeof(int)); usedNodeCounter++; usedNodeIDsIT++; nodesIT++; } } cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] setting number of nodes ... " << flush; ios::pos_type positionInFile = fout.tellp(); fout.seekp(ios::beg); fout.write((char*)&usedNodeCounter, sizeof(unsigned)); fout.seekp(positionInFile); cout << "ok" << endl; time = get_timestamp(); // Sort edges by start. cout << "[extractor] Sorting edges by start ... " << flush; stxxl::sort(externalMemory.allEdges.begin(), externalMemory.allEdges.end(), CmpEdgeByStartID(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] Setting start coords ... " << flush; fout.write((char*)&usedEdgeCounter, sizeof(unsigned)); // Traverse list of edges and nodes in parallel and set start coord nodesIT = externalMemory.allNodes.begin(); STXXLEdgeVector::iterator edgeIT = externalMemory.allEdges.begin(); while(edgeIT != externalMemory.allEdges.end() && nodesIT != externalMemory.allNodes.end()) { if(edgeIT->start < nodesIT->id){ edgeIT++; continue; } if(edgeIT->start > nodesIT->id) { nodesIT++; continue; } if(edgeIT->start == nodesIT->id) { edgeIT->startCoord.lat = nodesIT->lat; edgeIT->startCoord.lon = nodesIT->lon; edgeIT++; } } cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); // Sort Edges by target cout << "[extractor] Sorting edges by target ... " << flush; stxxl::sort(externalMemory.allEdges.begin(), externalMemory.allEdges.end(), CmpEdgeByTargetID(), memory_to_use); cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] Setting target coords ... " << flush; // Traverse list of edges and nodes in parallel and set target coord nodesIT = externalMemory.allNodes.begin(); edgeIT = externalMemory.allEdges.begin(); while(edgeIT != externalMemory.allEdges.end() && nodesIT != externalMemory.allNodes.end()) { if(edgeIT->target < nodesIT->id){ edgeIT++; continue; } if(edgeIT->target > nodesIT->id) { nodesIT++; continue; } if(edgeIT->target == nodesIT->id) { if(edgeIT->startCoord.lat != INT_MIN && edgeIT->startCoord.lon != INT_MIN) { edgeIT->targetCoord.lat = nodesIT->lat; edgeIT->targetCoord.lon = nodesIT->lon; double distance = ApproximateDistance(edgeIT->startCoord.lat, edgeIT->startCoord.lon, nodesIT->lat, nodesIT->lon); if(edgeIT->speed == -1) edgeIT->speed = settings.speedProfile.speed[edgeIT->type]; double weight = ( distance * 10. ) / (edgeIT->speed / 3.6); int intWeight = max(1, (int) weight); int intDist = max(1, (int)distance); int ferryIndex = settings.indexInAccessListOf("ferry"); assert(ferryIndex != -1); short zero = 0; short one = 1; fout.write((char*)&edgeIT->start, sizeof(unsigned)); fout.write((char*)&edgeIT->target, sizeof(unsigned)); fout.write((char*)&intDist, sizeof(int)); switch(edgeIT->direction) { case _Way::notSure: fout.write((char*)&zero, sizeof(short)); break; case _Way::oneway: fout.write((char*)&one, sizeof(short)); break; case _Way::bidirectional: fout.write((char*)&zero, sizeof(short)); break; case _Way::opposite: fout.write((char*)&one, sizeof(short)); break; default: cerr << "[error] edge with no direction: " << edgeIT->direction << endl; assert(false); break; } fout.write((char*)&intWeight, sizeof(int)); short edgeType = edgeIT->type; fout.write((char*)&edgeType, sizeof(short)); fout.write((char*)&edgeIT->nameID, sizeof(unsigned)); } usedEdgeCounter++; edgeIT++; } } cout << "ok, after " << get_timestamp() - time << "s" << endl; time = get_timestamp(); cout << "[extractor] setting number of edges ... " << flush; fout.seekp(positionInFile); fout.write((char*)&usedEdgeCounter, sizeof(unsigned)); fout.close(); cout << "ok" << endl; time = get_timestamp(); cout << "[extractor] writing street name index ... " << flush; vector<unsigned> * nameIndex = new vector<unsigned>(externalMemory.nameVector.size()+1, 0); outputFileName.append(".names"); ofstream nameOutFile(outputFileName.c_str(), ios::binary); unsigned sizeOfNameIndex = nameIndex->size(); nameOutFile.write((char *)&(sizeOfNameIndex), sizeof(unsigned)); for(STXXLStringVector::iterator it = externalMemory.nameVector.begin(); it != externalMemory.nameVector.end(); it++) { unsigned lengthOfRawString = strlen(it->c_str()); nameOutFile.write((char *)&(lengthOfRawString), sizeof(unsigned)); nameOutFile.write(it->c_str(), lengthOfRawString); } nameOutFile.close(); delete nameIndex; cout << "ok, after " << get_timestamp() - time << "s" << endl; // time = get_timestamp(); // cout << "[extractor] writing address list ... " << flush; // // adressFileName.append(".address"); // ofstream addressOutFile(adressFileName.c_str()); // for(STXXLAddressVector::iterator it = adressVector.begin(); it != adressVector.end(); it++) { // addressOutFile << it->node.id << "|" << it->node.lat << "|" << it->node.lon << "|" << it->city << "|" << it->street << "|" << it->housenumber << "|" << it->state << "|" << it->country << "\n"; // } // addressOutFile.close(); // cout << "ok, after " << get_timestamp() - time << "s" << endl; } catch ( const exception& e ) { cerr << "Caught Execption:" << e.what() << endl; return false; } delete extractCallBacks; cout << "[extractor] finished." << endl; return 0; }