srs/WKTParser.h

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

    TerraLib 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 3 of the License,
    or (at your option) any later version.

    TerraLib 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 TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */

/*! 
  \file WKTParser.h

  \brief A class that implements the grammar rules for well known text (WKT) of Spatial Reference Systems.
         It is based on boost::spirit V2 and WKT BNF definition available in the OGC Coordinate Transformation
         Services Specification - Revision 1.00 - pages 18 and 19.

  \warning Do not use this class. It is for TerraLib internal use. Try the te::srs::WKTReader instead.
 */

#ifndef __TERRALIB_SRS_INTERNAL_WKTPARSER_H
#define __TERRALIB_SRS_INTERNAL_WKTPARSER_H

// TerraLib
#include "WKTActions.h"

// boost
#include <boost/bind/bind.hpp>
#include <boost/spirit/include/qi.hpp>

// STL
#include <iostream>
#include <string>

// Auxiliaries namespaces
namespace qi    = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

// Using the following boost::spirit definitions
using qi::as_string;
using qi::char_;
using qi::double_;
using ascii::no_case;

namespace te
{
  namespace srs
  {
    /*!
      \class WKTParser
      
      \brief A class that implements the Grammar Rules for well known text (WKT) format of Spatial Reference Systems.
     */
    template<typename Iterator>
    class WKTParser : public qi::grammar<Iterator, ascii::space_type>
    {
      public:

        /** @name Constructor
         *  Initilizer methods.
         */
        //@{

        /*! \brief Default constructor. */
        WKTParser() : WKTParser::base_type(srs)
        {
          srs = geographicCS | projectedCS;

          // Initializing all rules
          initTags();
          initSpatialReferenceSystems();
          initDatum();
          initToWGS84();
          initProjection();
          initParameter();
          initAxis();
          initSpheroid();
          initPrimeMeridian();
          initUnits();
          initDoubleValues();
          initQuotedNames();
          initAuthority();
          initDelimiters();
        }

        //@}

      private:
        
        /** @name Initializer methods.
          *  Methods to initialize the grammar rules.
          */
        //@{

        void initTags()
        {
          projectedCSTag = "PROJCS";
          geographicCSTag = "GEOGCS";
          datumTag = "DATUM";
          toWGS84Tag = "TOWGS84";
          spheroidTag = "SPHEROID";
          projectionTag = "PROJECTION";
          parameterTag = "PARAMETER";
          primeMeridianTag = "PRIMEM";
          unitTag = "UNIT";
          authorityTag = "AUTHORITY";
          axisTag = "AXIS";
          northTag = "NORTH";
          southTag = "SOUTH";
          eastTag = "EAST";
          westTag = "WEST";
          upTag = "UP";
          downTag = "DOWN";
          otherTag = "OTHER";
        }

        void initSpatialReferenceSystems()
        {
          projectedCS = (projectedCSTag[boost::bind(&WKTActions::createProjectedCoordinateSystem, &m_a)]
                        >> leftDelimiter
                        >> csName >> ',' 
                        >> geographicCS >> ',' 
                        >> projection >> *(',' >> parameter) >> *(',' >> axis)
                        >> ',' >> unit >> *(',' >> axis) >> -(',' >> authority)
                        >> rigthDelimiter)[boost::bind(&WKTActions::endProjectedCoordinateSystem, &m_a)];

          geographicCS = (geographicCSTag[boost::bind(&WKTActions::createGeographicCoordinateSystem, &m_a)]
                         >> leftDelimiter 
                         >> csName >> ',' 
                         >> datum >> ',' 
                         >> primeMeridian >> ',' 
                         >> unit >> -(',' >> authority)
                         >> rigthDelimiter)[boost::bind(&WKTActions::endGeographicCoordinateSystem, &m_a)];
        }

        void initDatum()
        {
          datum = (datumTag[boost::bind(&WKTActions::createDatum, &m_a)]
                  >> leftDelimiter
                  >> datumName >> ','
                  >> spheroid >> -(',' >> toWGS84) >> -(',' >> authority)
                  >> rigthDelimiter)[boost::bind(&WKTActions::endDatum, &m_a)];
        }

        void initToWGS84()
        {
          toWGS84 = (toWGS84Tag >> leftDelimiter >> sevenParams >> rigthDelimiter)[boost::bind(&WKTActions::endToWGS84, &m_a)];
          sevenParams = dx >> ',' >> dy >> ',' >> dz >> ',' >> ex >> ',' >> ey >> ',' >> ez >> ',' >> ppm;

#if BOOST_VERSION < 106000
           dx = double_[boost::bind(&WKTActions::setDx, &m_a, ::_1)];
           dy = double_[boost::bind(&WKTActions::setDy, &m_a, ::_1)];
           dz = double_[boost::bind(&WKTActions::setDz, &m_a, ::_1)];
           ex = double_[boost::bind(&WKTActions::setEx, &m_a, ::_1)];
           ey = double_[boost::bind(&WKTActions::setEy, &m_a, ::_1)];
           ez = double_[boost::bind(&WKTActions::setEz, &m_a, ::_1)];
           ppm = double_[boost::bind(&WKTActions::setPPM, &m_a, ::_1)];
#else
          dx = double_[boost::bind(&WKTActions::setDx, &m_a, boost::placeholders::_1)];
          dy = double_[boost::bind(&WKTActions::setDy, &m_a, boost::placeholders::_1)];
          dz = double_[boost::bind(&WKTActions::setDz, &m_a, boost::placeholders::_1)];
          ex = double_[boost::bind(&WKTActions::setEx, &m_a, boost::placeholders::_1)];
          ey = double_[boost::bind(&WKTActions::setEy, &m_a, boost::placeholders::_1)];
          ez = double_[boost::bind(&WKTActions::setEz, &m_a, boost::placeholders::_1)];
          ppm = double_[boost::bind(&WKTActions::setPPM, &m_a, boost::placeholders::_1)];
#endif
        }

        void initProjection()
        {
          projection = projectionTag
                       >> leftDelimiter
                       >> projectionName >> -(',' >> authority)
                       >> rigthDelimiter;
        }

        void initParameter()
        {
          parameter = parameterTag
                      >> leftDelimiter
                      >> parameterName >> ','
                      >> value
                      >> rigthDelimiter;
        }

        void initSpheroid()
        {
          spheroid = (spheroidTag[boost::bind(&WKTActions::createSpheroid, &m_a)]
                     >> leftDelimiter
                     >> spheroidName >> ','
                     >> semiMajorAxis >> ','
                     >> invFlattening >> -(',' >> authority)
                     >> rigthDelimiter)[boost::bind(&WKTActions::endSpheroid, &m_a)];
        }

        void initPrimeMeridian()
        {
          primeMeridian = primeMeridianTag
                          >> leftDelimiter
                          >> primeMeridianName >> ','
                          >> longitude >> -(',' >> authority)
                          >> rigthDelimiter;
        }

        void initUnits()
        {
          unit = unitTag
                 >> leftDelimiter
                 >> unitName >> ','
                 >> conversionFactor >> -(',' >> authority)
                 >> rigthDelimiter;
        }

        void initQuotedNames()
        {
#if BOOST_VERSION < 106000
          unitName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setUnitName, &m_a, ::_1)] >> '"';
          
          spheroidName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setSpheroidName, &m_a, ::_1)] >> '"';
          
          projectionName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setProjectionName, &m_a, ::_1)] >> '"';
          
          datumName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setDatumName, &m_a, ::_1)] >> '"';
          
          axisName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setAxisName, &m_a, ::_1)] >> '"';
          
          axisValue = as_string[(+(char_ - ']'))][boost::bind(&WKTActions::setAxisValue, &m_a, ::_1)];

          csName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setName, &m_a, ::_1)] >> '"';
          
          parameterName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setParameter, &m_a, ::_1)] >> '"';
#else
          unitName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setUnitName, &m_a, boost::placeholders::_1)] >> '"';
          
          spheroidName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setSpheroidName, &m_a, boost::placeholders::_1)] >> '"';
          
          projectionName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setProjectionName, &m_a, boost::placeholders::_1)] >> '"';
          
          datumName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setDatumName, &m_a, boost::placeholders::_1)] >> '"';
          
          axisName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setAxisName, &m_a, boost::placeholders::_1)] >> '"';
          
          axisValue = as_string[(+(char_ - ']'))][boost::bind(&WKTActions::setAxisValue, &m_a, boost::placeholders::_1)];

          csName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setName, &m_a, boost::placeholders::_1)] >> '"';
          
          parameterName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setParameter, &m_a, boost::placeholders::_1)] >> '"';
#endif
          
          primeMeridianName = '"' >> (+(char_ - '"')) >> '"';
        }

        void initDoubleValues()
        {
#if BOOST_VERSION < 106000
          value = double_[boost::bind(&WKTActions::setParameterValue, &m_a, ::_1)];
          
          semiMajorAxis = double_[boost::bind(&WKTActions::setSemiMajorAxis, &m_a, ::_1)];
          
          longitude = double_[boost::bind(&WKTActions::setPrimeMeridian, &m_a, ::_1)];
          
          invFlattening = double_[boost::bind(&WKTActions::setInverseFlattening, &m_a, ::_1)];
          
          conversionFactor = double_[boost::bind(&WKTActions::setConversionFactor, &m_a, ::_1)];

#else
          value = double_[boost::bind(&WKTActions::setParameterValue, &m_a, boost::placeholders::_1)];
          
          semiMajorAxis = double_[boost::bind(&WKTActions::setSemiMajorAxis, &m_a, boost::placeholders::_1)];
          
          longitude = double_[boost::bind(&WKTActions::setPrimeMeridian, &m_a, boost::placeholders::_1)];
          
          invFlattening = double_[boost::bind(&WKTActions::setInverseFlattening, &m_a, boost::placeholders::_1)];
          
          conversionFactor = double_[boost::bind(&WKTActions::setConversionFactor, &m_a, boost::placeholders::_1)];
#endif
        }

        void initAuthority()
        {
          authority = authorityTag >> leftDelimiter >> authorityName >> ',' >> authorityCode >> rigthDelimiter;
#if BOOST_VERSION < 106000
          authorityName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setAuthorityName, &m_a, ::_1)] >> '"';
          authorityCode = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setAuthorityCode, &m_a, ::_1)] >> '"';
#else
          authorityName = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setAuthorityName, &m_a, boost::placeholders::_1)] >> '"';
          authorityCode = '"' >> as_string[(+(char_ - '"'))][boost::bind(&WKTActions::setAuthorityCode, &m_a, boost::placeholders::_1)] >> '"';
#endif
        }

        void initAxis()
        {
          axisValue = northTag | southTag | eastTag | westTag| upTag | downTag | otherTag;

          axis = axisTag
            >> leftDelimiter
            >> axisName >> ','
            >> axisValue
            >> rigthDelimiter;
        }
        

        void initDelimiters()
        {
          leftDelimiter  = char_('(') | char_('['); 
          rigthDelimiter = char_(')') | char_(']'); 
        }

        //@}
          
      public:
        
        /** @name Access method.
        * Method to access the SRS generated.
        */
        //@{

        /*!
          \brief It returns the SRS generated by the parser process.

          \note The caller of this method will take the ownership of the SRS.
         */
        SpatialReferenceSystem* getSRS() { return m_a.getSRS(); }
        
        //@}

        /*! 
          \brief This method resets the Parser to original state. 
          
          \note Should be called case the parser processing faill.
          \note Basically, it is responsable to free the memory.
         */
        void reset() { m_a.reset(); }

      private:

        WKTActions m_a; //<! Semanthic actions to grammar rules.

        /** @name Rules of WKT Grammar.
          */
        //@{

        qi::rule<Iterator, ascii::space_type> srs;

        qi::rule<Iterator, ascii::space_type> projectedCS, geographicCS;

        qi::rule<Iterator, ascii::space_type> projectedCSTag, geographicCSTag, datumTag, spheroidTag, projectionTag, 
          parameterTag, primeMeridianTag, unitTag, toWGS84Tag, authorityTag, axisTag, northTag, southTag, eastTag,
          westTag, upTag, downTag, otherTag;

        qi::rule<Iterator, ascii::space_type> datum;

        qi::rule<Iterator, ascii::space_type> toWGS84, sevenParams;

        qi::rule<Iterator, ascii::space_type> dx, dy, dz, ex, ey, ez, ppm;

        qi::rule<Iterator, ascii::space_type> projection;

        qi::rule<Iterator, ascii::space_type> parameter;

        qi::rule<Iterator, ascii::space_type> spheroid;

        qi::rule<Iterator, ascii::space_type> primeMeridian;

        qi::rule<Iterator, ascii::space_type> unit;

        qi::rule<Iterator, ascii::space_type> axis;

        qi::rule<Iterator, ascii::space_type> axisValue;

        qi::rule<Iterator, ascii::space_type> value, semiMajorAxis, longitude, invFlattening, conversionFactor;

        qi::rule<Iterator> unitName, spheroidName, projectionName, primeMeridianName, parameterName, datumName, csName, axisName;

        qi::rule<Iterator, ascii::space_type> authority, authorityCode;

        qi::rule<Iterator> authorityName;

        qi::rule<Iterator, ascii::space_type> leftDelimiter, rigthDelimiter;

        //@}

    }; // WKTParser

  } // namespace srs
}   // namespace te

#endif  // __TERRALIB_SRS_INTERNAL_WKTPARSER_H