inline void PBFParser::ParseData() {
while (true) {
_ThreadData *threadData;
threadDataQueue->wait_and_pop(threadData);
if( NULL==threadData ) {
SimpleLogger().Write() << "Parse Data Thread Finished";
threadDataQueue->push(NULL); // Signal end of data for other threads
break;
}
loadBlock(threadData);
for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
threadData->currentGroupID = i;
loadGroup(threadData);
if(threadData->entityTypeIndicator == TypeNode) {
parseNode(threadData);
}
if(threadData->entityTypeIndicator == TypeWay) {
parseWay(threadData);
}
if(threadData->entityTypeIndicator == TypeRelation) {
parseRelation(threadData);
}
if(threadData->entityTypeIndicator == TypeDenseNode) {
parseDenseNode(threadData);
}
}
delete threadData;
threadData = NULL;
}
}
void operator()(const osmium::memory::Buffer& buffer)
{
for (const auto& item : buffer)
{
if (item.type() == osmium::item_type::way)
{
parseWay(static_cast<const osmium::Way&>(item));
}
}
}
inline void PBFParser::ParseData()
{
tbb::task_scheduler_init init(num_parser_threads);
while (true)
{
ParserThreadData *thread_data;
thread_data_queue->wait_and_pop(thread_data);
if (nullptr == thread_data)
{
thread_data_queue->push(nullptr); // Signal end of data for other threads
break;
}
loadBlock(thread_data);
int group_size = thread_data->PBFprimitiveBlock.primitivegroup_size();
for (int i = 0; i < group_size; ++i)
{
thread_data->currentGroupID = i;
loadGroup(thread_data);
if (thread_data->entityTypeIndicator == TypeNode)
{
parseNode(thread_data);
}
if (thread_data->entityTypeIndicator == TypeWay)
{
parseWay(thread_data);
}
if (thread_data->entityTypeIndicator == TypeRelation)
{
parseRelation(thread_data);
}
if (thread_data->entityTypeIndicator == TypeDenseNode)
{
parseDenseNode(thread_data);
}
}
delete thread_data;
thread_data = nullptr;
}
}
Map* parseElements(xmlDocPtr doc, xmlNodePtr cur){
Map* map = initMap();
Node *node;
Way* way;
Relation *r;
Avl* aNode = NULL;
Avl* avlWay = NULL;
ListNode* ln = NULL;
ListWay* wO = NULL;
ListWay* wW = NULL;
ListWay* wG = NULL;
ListWay* wH = NULL;
ListWay* wB = NULL;
ListWay* wC = NULL;
ListRelation* lr= NULL;
int flagN = 1;
int flagW = 1;
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
if (!xmlStrcmp(cur->name, (const xmlChar *)"bounds")){
map->bounds = parseBounds(cur);
}
if ((!xmlStrcmp(cur->name, (const xmlChar *)"node"))){
node = parseNode (doc, cur, map->bounds);
if(node->name!=NULL){
ln = addRefListNode(node->id,ln);
}
if(flagN == 1){
init(&aNode,node,NULL);
flagN = 0;
}
else{
insert(&aNode,node,NULL);
}
}
if ((!xmlStrcmp(cur->name, (const xmlChar *)"way"))){
way = parseWay (doc, cur, map->referenceTag);
if(way != NULL){
if((way->tag->type) == 0){
wO = addRefListWay(way->id," ", wO);
}
else if(way->tag->type == 1){
wW = addRefListWay(way->id," ", wW);
}
else if(way->tag->type == 2){
wG = addRefListWay(way->id," ", wG);
}
else if(way->tag->type == 3){
wH = addRefListWay(way->id," ", wH);
}
else if(way->tag->type == 4){
wB = addRefListWay(way->id," ", wB);
}
else if(way->tag->type == 5){
wC = addRefListWay(way->id," ", wC);
}
if(flagW == 1){
init(&avlWay,NULL, way);
flagW = 0;
}
else{
insert(&avlWay,NULL,way);
}
}
}
if ((!xmlStrcmp(cur->name, (const xmlChar *)"relation"))){
r = parseRelation(doc, cur);
if(r != NULL){
lr = addRefListRelation(r,lr);
}
}
}
cur = cur->next;
}
map->avl = aNode;
map->avlWay = avlWay;
map->nodeOther = ln;
map->wayWater = wW;
map->wayOther = wO;
map->wayGreen = wG;
map->wayBuilding = wB;
map->wayHighway = wH;
map->wayCadastre = wC;
map->listRelation = lr;
Node* n0 = initNode(0, map->bounds->min->y, map->bounds->min->x, "true", map->bounds, NULL);
Node* n1 = initNode(1, map->bounds->max->y, map->bounds->min->x, "true", map->bounds, NULL);
Node* n2 = initNode(2, map->bounds->max->y, map->bounds->max->x, "true", map->bounds, NULL);
Node* n3 = initNode(3, map->bounds->min->y, map->bounds->max->x, "true", map->bounds, NULL);
insert(&aNode,n0,NULL);
insert(&aNode,n1,NULL);
insert(&aNode,n2,NULL);
insert(&aNode,n3,NULL);
map->bounds = convertBounds(map->bounds);
return map;
}
