mapnik/plugins/input/osm/osm.cpp

/*****************************************************************************
 *
 * This file is part of Mapnik (c++ mapping toolkit)
 *
 * Copyright (C) 2011 Artem Pavlenko
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *****************************************************************************/

#include "osm.h"
#include "osmparser.h"
#include "basiccurl.h"

#include <libxml/parser.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>

polygon_types osm_way::ptypes;

bool osm_dataset::load(const char* filename,const std::string& parser)
{
    if (parser == "libxml2")
    {
        return osmparser::parse(this, filename);
    }
    return false;
}

bool osm_dataset::load_from_url(const std::string& url,
                                const std::string& bbox,
                                const std::string& parser)
{
    if (parser == "libxml2")
    {
#ifdef MAPNIK_DEBUG
        std::clog << "Osm Plugin: osm_dataset::load_from_url url=" << url << " bbox=" << bbox << std::endl;
#endif

        std::ostringstream str;
        // use curl to grab the data
        // fetch all the data we want - probably from osmxpai

        str << url << "?bbox=" << bbox;

#ifdef MAPNIK_DEBUG
        std::clog << "Osm Plugin: FULL URL " << str.str() << std::endl;
#endif

        CURL_LOAD_DATA* resp = grab_http_response(str.str().c_str());

        if (resp != NULL)
        {
            char *blx = new char[resp->nbytes + 1];
            memcpy(blx, resp->data, resp->nbytes);
            blx[resp->nbytes] = '\0';

#ifdef MAPNIK_DEBUG
            std::clog << "Osm Plugin: CURL RESPONSE: " << blx << std::endl;
#endif

            delete[] blx;
            bool success = osmparser::parse(this, resp->data, resp->nbytes);
            return success;
        }
    }
    return false;
}

osm_dataset::~osm_dataset()
{
    clear();
}

void osm_dataset::clear()
{
#ifdef MAPNIK_DEBUG
    std::clog << "Osm Plugin: osm_dataset::clear()" << std::endl;
    std::clog << "Osm Plugin: deleting ways" << std::endl;
#endif

    for (unsigned int count = 0; count < ways.size(); ++count)
    {
        delete ways[count];
        ways[count] = NULL;
    }

#ifdef MAPNIK_DEBUG
    std::clog << "Osm Plugin: deleting nodes" << std::endl;
#endif

    for (unsigned int count = 0; count < nodes.size(); ++count)
    {
        delete nodes[count];
        nodes[count] = NULL;
    }

#ifdef MAPNIK_DEBUG
    std::clog << "Osm Plugin: clearing ways/nodes" << std::endl;
#endif

    ways.clear();
    nodes.clear();

#ifdef MAPNIK_DEBUG
    std::clog << "Osm Plugin: done" << std::endl;
#endif
}

std::string osm_dataset::to_string()
{
    std::string result;

    for (unsigned int count = 0; count < nodes.size(); ++count)
    {
        result += nodes[count]->to_string();
    }

    for (unsigned int count = 0; count < ways.size(); ++count)
    {
        result += ways[count]->to_string();
    }

    return result;
}

bounds osm_dataset::get_bounds()
{
    bounds b (-180, -90, 180, 90);
    for (unsigned int count = 0; count < nodes.size(); ++count)
    {
        if(nodes[count]->lon > b.w) b.w = nodes[count]->lon;
        if(nodes[count]->lon < b.e) b.e = nodes[count]->lon;
        if(nodes[count]->lat > b.s) b.s = nodes[count]->lat;
        if(nodes[count]->lat < b.n) b.n = nodes[count]->lat;
    }
    return b;
}

osm_node* osm_dataset::next_node()
{
    if (node_i != nodes.end())
    {
        return *(node_i++);
    }
    return NULL;
}

osm_way* osm_dataset::next_way()
{
    if (way_i != ways.end())
    {
        return *(way_i++);
    }
    return NULL;
}

osm_item* osm_dataset::next_item()
{
    osm_item* item = NULL;
    if (next_item_mode == Node)
    {
        item = next_node();
        if (item == NULL)
        {
            next_item_mode = Way;
            rewind_ways();
            item = next_way();
        }
    }
    else
    {
        item = next_way();
    }
    return item;
}

std::set<std::string> osm_dataset::get_keys()
{
    std::set<std::string> keys;
    for (unsigned int count = 0; count < nodes.size(); ++count)
    {
        for (std::map<std::string, std::string>::iterator i = nodes[count]->keyvals.begin();
             i != nodes[count]->keyvals.end(); i++)
        {
            keys.insert(i->first);
        }
    }

    for (unsigned int count = 0; count < ways.size(); ++count)
    {
        for (std::map<std::string, std::string>::iterator i = ways[count]->keyvals.begin();
             i != ways[count]->keyvals.end(); i++)
        {
            keys.insert(i->first);
        }
    }
    return keys;
}


std::string osm_item::to_string()
{
    std::ostringstream strm;
    strm << "id=" << id << std::endl << "Keyvals: " << std::endl;

    for (std::map<std::string, std::string>::iterator i = keyvals.begin();
         i != keyvals.end(); i++)
    {
        strm << "Key " << i->first << " Value " << i->second << std::endl;
    }

    return strm.str();
}

std::string osm_node::to_string()
{
    std::ostringstream strm;
    strm << "Node: " << osm_item::to_string() << " lat=" << lat <<" lon="  <<lon << std::endl;
    return strm.str();
}

std::string osm_way::to_string()
{
    std::ostringstream strm;
    strm << "Way: " << osm_item::to_string() << "Nodes in way:";

    for (unsigned int count = 0; count < nodes.size(); ++count)
    {
        if (nodes[count] != NULL)
        {
            strm << nodes[count]->id << " ";
        }
    }

    strm << std::endl;
    return strm.str();
}

bounds osm_way::get_bounds()
{
    bounds b (-180, -90, 180, 90);

    for (unsigned int count = 0; count < nodes.size(); ++count)
    {
        if(nodes[count]->lon > b.w) b.w = nodes[count]->lon;
        if(nodes[count]->lon < b.e) b.e = nodes[count]->lon;
        if(nodes[count]->lat > b.s) b.s = nodes[count]->lat;
        if(nodes[count]->lat < b.n) b.n = nodes[count]->lat;
    }
    return b;
}

bool osm_way::is_polygon()
{
    for (unsigned int count = 0; count < ptypes.ptypes.size(); ++count)
    {
        if (keyvals.find(ptypes.ptypes[count].first) != keyvals.end() &&
            keyvals[ptypes.ptypes[count].first] == ptypes.ptypes[count].second)
        {
            return true;
        }
    }

    return false;
}