Path.hpp

Go to the documentation of this file.

#pragma ident "$Id: Path.hpp 1644 2009-01-27 19:26:14Z ckiesch $"


//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk 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
//  any later version.
//
//  The GPSTk 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 GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================


#ifndef VDRAW_PATH_H
#define VDRAW_PATH_H

#include<string>
#include<vector>
#include<utility> // std::pair
#include<memory>  // std::auto_ptr

// TODO In the future?
// #include "boost/shared_ptr.hpp" // boost::shared_ptr
// To use shared_ptr instead of auto_ptr

#include "GraphicsConstants.hpp"
#include "VDrawException.hpp"

namespace vdraw
{

  struct Point : public std::pair<double, double>
  {
    Point(double ix=0.0, double iy=0.0)
      : std::pair<double,double>(ix,iy)
    {
    }

    Point(const Point& p)
      : std::pair<double,double>(p.x(),p.y())
    {
    }

    Point(const std::pair<double,double>& o)
      : std::pair<double,double>(o)
    {
    }

    double& x() { return first; }

    const double& x() const { return first; }

    double& y() { return second; }

    const double& y() const { return second; }

  };

  class Path: public std::vector< Point > 
  {
    public:

      Path(unsigned int estimated_size=0) 
        : originX(0.0), originY(0.0)
      {
        if(estimated_size)
          reserve(estimated_size);
      }

      Path(double iOriginX, double iOriginY, unsigned int estimated_size=0) 
        : originX(iOriginX), originY(iOriginY)
      {
        if(estimated_size)
          reserve(estimated_size);
      }

      Path(const std::vector< std::pair<double,double> >& v, double iOriginX=0, double iOriginY=0)
      {
        originX = iOriginX;
        originY = iOriginY;
        reserve(v.size());
        std::vector< std::pair<double,double> >::const_iterator i;
        for(i=v.begin(); i!=v.end(); i++)
        {
          if(size()==0 
              || (i->first != (*this)[size()-1].x()) 
              || (i->second != (*this)[size()-1].y()))
            push_back(Point(*i));
        }
        tighten();
      }

      inline void tighten()
      {
        resize(size());
      }

      inline void setOrigin(double X, double Y)
      { 
        originX = X; 
        originY = Y; 
        return; 
      }

      inline void getOrigin(double& X, double& Y) const
      { 
        X = originX; 
        Y = originY; 
        return; 
      }

      void addPointAbsolute(double X, double Y);

      void addPointRelative(double X, double Y);

      void addPointDelta(double DX, double DY) throw (VDrawException);

      void rotate(double angleDegrees, double rx, double ry);

      void rotate(double angleDegrees);

      void translate(double deltaX, double deltaY);

      void scale(double factor, double sx, double sy);

      std::auto_ptr<Path> asAbsolute(void) const;

    protected:

    private:
      double originX; 
      double originY;

  }; // class Path


} // namespace vdraw

#endif //VDRAW_PLOT_PATH_H

---