Path.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef BOARD_PATH_H
#define BOARD_PATH_H
 
#include <initializer_list>
#include <iostream>
#include <vector>
#include "board/Point.h"
#include "board/Rect.h"
#include "board/Transforms.h"
 
// TODO : Add a resample (uniformly wrt to length) method
 
namespace LibBoard
{
 
struct Path {
 
  typedef std::vector<Point>::size_type size_type;
 
  enum OpenClosed
  {
    OpenPath,
    ClosedPath
  };
 
  Path() : _openClosed(OpenPath) {}
 
  Path(const std::vector<Point> & points, OpenClosed openClosed) : _points(points), _openClosed(openClosed) {}
 
  Path(std::initializer_list<Point> points);
 
  // Path(std::initializer_list<Point> points);
 
  explicit Path(OpenClosed openClosed) : _openClosed(openClosed) {}
 
  inline void clear();
 
  inline bool isClosed() const;
 
  inline bool isOpen() const;
 
  inline bool empty() const;
 
  inline std::size_t size() const;
 
  inline void close();
 
  inline OpenClosed openClosed() const;
 
  inline void open();
 
  inline void setOpenClosed(OpenClosed openClosed);
 
  Point center() const;
 
  Path & operator<<(const Point & p);
 
  Path & operator<<(const std::vector<Point> & v);
 
  Path & pop_back();
 
  Path & push_back(const Point & p);
 
  inline const Point & front() const;
 
  inline const Point & back() const;
 
  inline Point & operator[](const std::size_t n);
 
  inline const Point & operator[](const std::size_t n) const;
 
  Path & rotate(double angle, const Point & center);
 
  Path & rotateDeg(double angle, const Point & center);
 
  Path rotated(double angle, const Point & center) const;
 
  Path rotatedDeg(double angle, const Point & center) const;
 
  Path & rotate(double angle);
 
  Path & rotateDeg(double angle);
 
  Path rotated(double angle) const;
 
  Path rotatedDeg(double angle) const;
 
  Path & translate(double dx, double dy);
 
  Path translated(double dx, double dy) const;
 
  Path & moveCenter(double x, double y);
 
  Path & moveCenter(Point p);
 
  Path & scale(double sx, double sy);
 
  Path & scale(double s);
 
  Path scaled(double sx, double sy) const;
 
  Path scaled(double s) const;
 
  void scaleAll(double s);
 
  void flushPostscript(std::ostream & stream, const TransformEPS & transform) const;
 
  void flushFIG(std::ostream & stream, const TransformFIG & transform) const;
 
  void flushSVGPoints(std::ostream & stream, const TransformSVG & transform) const;
 
  void flushSVGCommands(std::ostream & stream, const TransformSVG & transform) const;
 
  void flushTikZPoints(std::ostream & stream, const TransformTikZ & transform) const;
 
  Path transformed(const Transform & transform) const;
 
  bool isClockwise() const;
 
  bool isCounterclockwise() const;
 
  void setClockwise();
 
  void setCounterclockwise();
 
  Path getClockwise() const;
 
  Path getCounterclockwise() const;
 
  Rect boundingBox() const;
 
  const std::vector<Point> & points() const;
 
  std::ostream & flush(std::ostream &) const;
 
  inline std::vector<Point>::const_iterator begin() const;
  inline std::vector<Point>::const_iterator cbegin() const;
  inline std::vector<Point>::const_iterator end() const;
  inline std::vector<Point>::const_iterator cend() const;
 
protected:
  std::vector<Point> _points;
  OpenClosed _openClosed;
};
 
Path mid(const Path & a, const Path & b, double time);
 
// Inline methods
 
void Path::clear()
{
  _points.clear();
}
 
Point & Path::operator[](const std::size_t n)
{
  return _points[n];
}
 
const Point & Path::operator[](const std::size_t n) const
{
  return _points[n];
}
 
std::vector<Point>::const_iterator Path::begin() const
{
  return _points.begin();
}
 
std::vector<Point>::const_iterator Path::cbegin() const
{
  return _points.begin();
}
 
std::vector<Point>::const_iterator Path::end() const
{
  return _points.end();
}
 
std::vector<Point>::const_iterator Path::cend() const
{
  return _points.cend();
}
 
bool Path::isClosed() const
{
  return _openClosed == ClosedPath;
}
 
bool Path::isOpen() const
{
  return _openClosed == OpenPath;
}
 
bool Path::empty() const
{
  return _points.empty();
}
 
std::size_t Path::size() const
{
  return _points.size();
}
 
void Path::close()
{
  _openClosed = ClosedPath;
}
 
Path::OpenClosed Path::openClosed() const
{
  return _openClosed;
}
 
void Path::open()
{
  _openClosed = OpenPath;
}
 
const Point & Path::front() const
{
  return _points.front();
}
 
const Point & Path::back() const
{
  return _points.back();
}
 
} // namespace LibBoard
 
std::ostream & operator<<(std::ostream & out, const LibBoard::Path & path);
 
#endif /* BOARD_PATH_H */