kml_parser.H

#ifndef CAJUN_KML_PARSER_H
#define CAJUN_KML_PARSER_H


// Copyright (C) 2006, 2007 University of Louisiana at Lafayette
// Authors: Christopher Vaughn

#include <map>
#include <list>
#include <string>
#include <vector>
#include <cmath>
#include <fstream>
#include <iostream>
#include <libxml/parser.h>
#include <libxml/tree.h>

#include "proj_util.H"
#include "rndf.H"

#define D2R     (M_PI / 180)

#define MAX_OBSTACLE_AREAS 25
namespace cajun
{
  class rndf_builder_t;
}

namespace cajun 
{
class kmlWP{
public: 
        double lat_;
        double lon_;
        bool operator== (kmlWP const &k_) const
        {
                double lat_diff = lat_ - k_.lat_;
                double lon_diff = lon_ - k_.lon_;
                if(lat_diff < 0)
                        lat_diff *= -1;
                if(lon_diff < 0)
                        lon_diff *= -1;
                //std::cout<<"DIFF "<<lat_diff<<std::endl;
                return  lat_diff < 0.000001 && 
                        lon_diff < 0.000001;
        }
};

class anno_point_t
{
public:
        anno_point_t(){};
        anno_point_t(std::string n, kmlWP p):name(n), point(p){};
        std::string name;
        kmlWP point;
};


class kml_laneb_t
{
public:
        kml_laneb_t();
        kml_laneb_t(std::string name_);

        std::string getName();
        void addlaneb_point(std::vector<kmlWP> _points);
        unsigned* startID();
        unsigned* endID();
        std::vector<kmlWP> getlaneb_points();
                
private:
        std::string name;
        std::vector<kmlWP> laneb_points;
        unsigned start_id[3];
        unsigned end_id[3];
};



class kml_obstacle_t
{
public:
        kml_obstacle_t(){};
        kml_obstacle_t(std::string name, proj_t *proj_);

        void add_obstacle(std::vector<kmlWP> obs);
        void dump_obstacles(std::ofstream &o);

private:
        std::string area_name;
        unsigned int num_obstacles;
        proj_t *m_proj;
        std::vector< std::vector<kmlWP> > obst_list;    
};


class kml_parser_t
{
public:
        kml_parser_t(std::string const &path_, rndf_builder_t *builder_, proj_t *proj_);

        bool parse(std::string map_file);
        bool build_lb_files();
        bool build_obs_files();
        bool build_anno_files();
        std::vector<kml_laneb_t> getlaneb();
        bool cleanup();

protected:

        rndf_builder_t *m_builder;
        proj_t *m_proj;

        std::ofstream out_file;
        std::vector<kml_laneb_t> laneb;

        unsigned m_segment_count;
        unsigned m_lane_count;
        unsigned m_checkpoint_counter;
        
        xmlDocPtr m_doc;
        xmlNodePtr DocumentNode;

        unsigned int num_obstacle_areas;
        std::string obstacle_area_names[MAX_OBSTACLE_AREAS];
        kml_obstacle_t obstacle_area_list[MAX_OBSTACLE_AREAS];  

        std::multimap<std::string, std::string> exit_entrymap;

        std::list<anno_point_t> exitPoints;
        std::list<anno_point_t> entryPoints;
        std::list<anno_point_t> stopPoints;
        std::list<anno_point_t> cpPoints;

        std::map<std::string, rndf_t::waypoint_id_t> m_name2entry;

        std::map<rndf_t::waypoint_id_t, std::string> m_exit2name;
        std::map<rndf_t::waypoint_id_t, std::string> m_stop2name;
        std::map<rndf_t::waypoint_id_t, std::string> m_cp2name;

        void parse_mapfile(std::string mfile);
        void populate_anno_lists();
        void populateLists(xmlNodePtr start_node);
        void find_anno_matches(kmlWP c,unsigned wp_id[3] );

        xmlNodePtr getNextElement(xmlNodePtr node, char* node_name);

        xmlNodePtr getLaneBoundaryFolder(xmlNodePtr start_node);
        xmlNodePtr getObstacleFolder(xmlNodePtr start_node);
        xmlNodePtr getAnnotationsFolder(xmlNodePtr start_node);

        xmlNodePtr getSegmentsNode(xmlNodePtr start_node);
        int howManySegments(xmlNodePtr root_seg_node);
        int howManyLanes(xmlNodePtr lane_node);
        void processAllSegments(xmlNodePtr root_seg_node, bool preprocess);
        void processSegment(xmlNodePtr seg_node,  bool preprocess);
        void processLane(xmlNodePtr p_node,  bool preprocess);  
        bool isLane(xmlNodePtr start_node);

        xmlNodePtr getZonesNode(xmlNodePtr start_node);
        int howManyZones(xmlNodePtr root_zone_node);
        int howManySpots(xmlNodePtr zone_node);
        void processAllZones(xmlNodePtr root_zone_node, bool preprocess);
        void processZone(xmlNodePtr zone_node, bool preprocess);
        void processPerimeter(xmlNodePtr perm_node, bool preprocess);
        void processSpot(xmlNodePtr spot_node, bool preprocess);
        bool isPerimeter(xmlNodePtr pm_node);
        bool isSpot(xmlNodePtr pm_node);

        void processLaneBoundary(xmlNodePtr lb_node);
        void processLaneBoundaryLine(xmlNodePtr lb_node);

        void processObstacle(xmlNodePtr obs_node);
        void addObstacle(std::string area_name, std::vector<kmlWP> obs); 
        void dumpObstacles();

        void processAnnotations(xmlNodePtr anno_node);

        kmlWP processPoint(xmlNodePtr p_node);
        std::vector<kmlWP> processLine(xmlNodePtr l_node);
        std::vector<kmlWP> processPolygon(xmlNodePtr poly_node);
        std::vector<kmlWP> getPolygonCoord(xmlNodePtr poly_node);
        std::vector<kmlWP> processCoord(xmlChar* c);

        // will only return the first node with name node_name
        xmlNodePtr getNodeByName(xmlNodePtr start_node,xmlChar* node_name);
        // will return the contents of the first node with name "name"
        xmlChar* getName(xmlNodePtr start_node);
        xmlChar* getDescription(xmlNodePtr start_node);
        bool isVisible(xmlNodePtr start_node);
        bool isPoint(xmlNodePtr p_node);
        bool isLine(xmlNodePtr l_node);
        bool isPolygon(xmlNodePtr pl_node);
        
};
};
#endif

---