JUTMGrid.hh

Go to the documentation of this file.

#ifndef __JUTM__JUTMGRID__
#define __JUTM__JUTMGRID__
 
#include <string>
#include <ostream>
#include <ostream>
#include <sstream>
#include <ctype.h>
 
#include "JLang/JException.hh"
#include "JLang/JEquals.hh"
#include "JMath/JConstants.hh"
#include "JIO/JSerialisable.hh"
#include "JIO/JSTDIO.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JUTM {}
namespace JPP { using namespace JUTM; }
 
namespace JUTM {
 
  using JLANG::JParseError;
  using JLANG::JEquals;
  using JMATH::PI;
  using JIO::JReader;
  using JIO::JWriter;
 
  /**
   * UTM zone width [rad]
   *
   * The UTM system consists of 60 zones, each 6-degrees of longitude in width.\n
   * The zones are numbered 1-60, beginning at 180-degrees longitude and increasing to the East.
   */
  static const double UTM_ZONE_WIDTH_RAD  =  6.0 * PI / 180.0;
 
 
  /**
   * Get UTM zone for given longitude.
   *
   * \param  longitude     longitude [rad]
   * \return               UTM zone
   */
  inline int getUTMZone(const double longitude)
  {
    return 1 + int((PI + longitude) / UTM_ZONE_WIDTH_RAD);
  }
 
 
  /**
   * Get longitude of the central meridian for given UTM zone.
   *
   * \param  zone          UTM zone
   * \return               longitude of central meridian [rad]
   */
  static inline double getUTMLongitude(const int zone)
  {
    return  -PI + (zone - 1) * UTM_ZONE_WIDTH_RAD + 0.5*UTM_ZONE_WIDTH_RAD;
  }
 
 
  /**
   * Data structure for UTM grid.
   *
   * This data structure is composed of:
   *   - World Geodetic System;
   *   - UTM zone;
   */
  class JUTMGrid :
    public JEquals<JUTMGrid>
  {
  public:
    /**
     * Default constructor.
     */
    JUTMGrid() :
      key ("?"),
      wgs ("?"),
      zone("?")
    {}
 
 
    /**
     * Constructor.
     *
     * \param  key              key
     * \param  wgs              WGS
     * \param  zone             UTM zone
     */
    JUTMGrid(const std::string& key,
             const std::string& wgs,
             const std::string& zone)
    {
      this->key  = key;
      this->wgs  = wgs;
      this->zone = zone;
    }
 
 
    /**
     * Get UTM grid.
     *
     * \return               UTM grid
     */
    const JUTMGrid& getUTMGrid() const
    {
      return static_cast<const JUTMGrid&>(*this);
    }
 
 
    /**
     * Set UTM grid.
     *
     * \param  grid          UTM grid
     */
    void setUTMGrid(const JUTMGrid& grid)
    {
      static_cast<JUTMGrid&>(*this) = grid;
    }
 
 
    /**
     * Get key.
     *     
     * \return                  key
     */
    const std::string& getKey() const
    {
      return key;
    }
 
 
    /**
     * Get WGS.
     *     
     * \return                  WGS
     */
    const std::string& getWGS() const
    {
      return wgs;
    }
 
 
    /**
     * Get UTM zone.
     *     
     * \return                  UTM zone
     */
    const std::string& getUTMZone() const
    {
      return zone;
    }
 
 
    /**
     * Get UTM zone by numerical value.
     *
     * \return                  UTM zone
     */
    int getZone() const
    {
      using namespace std;
 
      int value = 0;
 
      for (string::const_iterator i = zone.begin(); i != zone.end(); ++i) {
        if (isdigit(*i))
          value = 10 * value  +  (*i - '0');
        else
          break;
      }
 
      return value;
    }
 
 
    /**
     * Check equality.
     *
     * \param  grid          UTM grid
     * \return               true if grids are equal; else false
     */
    bool equals(const JUTMGrid& grid) const
    {
      return (this->getKey()     == grid.getKey()  &&
              this->getWGS()     == grid.getWGS()  &&
              this->getUTMZone() == grid.getUTMZone());
    }
 
 
    /**
     * Convert UTM grid.
     *     
     * \return                  UTM grid
     */
    std::string toString() const
    {
      return (key + " " + wgs + " " + zone);
    }
 
 
    /**
     * Extract UTM grid.
     *
     * \param  buffer           WGS and UTM zone 
     * \return                  UTM grid
     */
    static JUTMGrid valueOf(const std::string& buffer)
    {
      JUTMGrid grid;
 
      std::istringstream is(buffer);
 
      if (is >> grid)
        return grid;
      else
        throw JParseError("JUTMGrid::valueOf()");
    }
 
 
    /**
     * Read UTM grid from input.
     *
     * \param  in               input stream
     * \param  grid             UTM grid
     * \return                  input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JUTMGrid& grid)
    {
      return in >> grid.key >> grid.wgs >> grid.zone;
    }
    
 
    /**
     * Write UTM grid to output.
     *
     * \param  out              output stream
     * \param  grid             UTM grid
     * \return                  output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JUTMGrid& grid)
    {
      return out << grid.key << ' ' << grid.wgs << ' ' << grid.zone;
    }
 
 
    /**
     * Read UTM grid from input.
     *
     * \param  in               input stream
     * \param  grid             UTM grid
     * \return                  input stream
     */
    friend inline JReader& operator>>(JReader& in, JUTMGrid& grid)
    {
      using namespace JIO;
 
      return in >> grid.key >> grid.wgs >> grid.zone;
    }
    
 
    /**
     * Write UTM grid to output.
     *
     * \param  out              output stream
     * \param  grid             UTM grid
     * \return                  output stream
     */
    friend inline JWriter& operator<<(JWriter& out, const JUTMGrid& grid)
    {
      using namespace JIO;
 
      return out << grid.key << grid.wgs << grid.zone;
    }
 
 
  protected:
    std::string key;
    std::string wgs;
    std::string zone;
  };
}
 
#endif