Polygon.hpp

Go to the documentation of this file.

/*
 * Polygon.hpp
 *
 *  Created on: Nov 7, 2014
 *      Author: Péter Fankhauser
 *   Institute: ETH Zurich, ANYbotics
 */

#pragma once

#include <grid_map_core/TypeDefs.hpp>

// STD
#include <vector>

// Eigen
#include <Eigen/Core>

namespace grid_map {

class Polygon
{
 public:

  enum class TriangulationMethods {
    FAN // Fan triangulation (only for convex polygons).
  };

  Polygon();

  Polygon(std::vector<Position> vertices);

  bool isInside(const Position& point) const;

  void addVertex(const Position& vertex);

  const Position& getVertex(size_t index) const;

  void removeVertices();

  const Position& operator [](size_t index) const;

  const std::vector<Position>& getVertices() const;

  size_t nVertices() const;

  void setTimestamp(uint64_t timestamp);

  uint64_t getTimestamp() const;

  void resetTimestamp();

  void setFrameId(const std::string& frameId);

  const std::string& getFrameId() const;

  double getArea() const;

  Position getCentroid() const;

  void getBoundingBox(Position& center, Length& length) const;

  bool convertToInequalityConstraints(Eigen::MatrixXd& A,
                                      Eigen::VectorXd& b) const;

  bool offsetInward(double margin);

  bool thickenLine(double thickness);

  std::vector<Polygon> triangulate(const TriangulationMethods& method = TriangulationMethods::FAN) const;

  static Polygon fromCircle(Position center, double radius,
                            int nVertices = 20);

  static Polygon convexHullOfTwoCircles(Position center1,
                                        Position center2,
                                        double radius,
                                        int nVertices = 20);

  static Polygon convexHull(Polygon& polygon1, Polygon& polygon2);

  static Polygon monotoneChainConvexHullOfPoints(const std::vector<Position>& points);

 protected:

  static bool sortVertices(const Eigen::Vector2d& vector1,
                           const Eigen::Vector2d& vector2);

  static double computeCrossProduct2D(const Eigen::Vector2d& vector1,
                                      const Eigen::Vector2d& vector2);

  static double vectorsMakeClockwiseTurn(const Eigen::Vector2d& pointO,
                                         const Eigen::Vector2d& pointA,
                                         const Eigen::Vector2d& pointB);
  // NOLINTBEGIN(misc-non-private-member-variables-in-classes)
  std::string frameId_;

  uint64_t timestamp_;

  std::vector<Position> vertices_;
  // NOLINTEND(misc-non-private-member-variables-in-classes)
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

} /* namespace grid_map */