polygon2d.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2017 The Apollo Authors. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *****************************************************************************/

#pragma once

#include <string>
#include <vector>

#include "modules/common/math/box2d.h"
#include "modules/common/math/line_segment2d.h"
#include "modules/common/math/vec2d.h"

namespace apollo {
namespace common {
namespace math {

class Polygon2d {
 public:
  Polygon2d() = default;

  explicit Polygon2d(const Box2d &box);

  explicit Polygon2d(std::vector<Vec2d> points);

  const std::vector<Vec2d> &points() const { return points_; }

  const std::vector<LineSegment2d> &line_segments() const {
    return line_segments_;
  }

  int num_points() const { return num_points_; }

  bool is_convex() const { return is_convex_; }

  double area() const { return area_; }

  double DistanceToBoundary(const Vec2d &point) const;

  double DistanceTo(const Vec2d &point) const;

  double DistanceTo(const LineSegment2d &line_segment) const;

  double DistanceTo(const Box2d &box) const;

  double DistanceTo(const Polygon2d &polygon) const;

  double DistanceSquareTo(const Vec2d &point) const;

  bool IsPointIn(const Vec2d &point) const;

  bool IsPointOnBoundary(const Vec2d &point) const;

  bool Contains(const LineSegment2d &line_segment) const;

  bool Contains(const Polygon2d &polygon) const;

  static bool ComputeConvexHull(const std::vector<Vec2d> &points,
                                Polygon2d *const polygon);

  bool HasOverlap(const LineSegment2d &line_segment) const;

  bool GetOverlap(const LineSegment2d &line_segment, Vec2d *const first,
                  Vec2d *const last) const;

  void GetAllVertices(std::vector<Vec2d> *const vertices) const;

  std::vector<Vec2d> GetAllVertices() const;

  std::vector<LineSegment2d> GetAllOverlaps(
      const LineSegment2d &line_segment) const;

  bool HasOverlap(const Polygon2d &polygon) const;

  // Only compute overlaps between two convex polygons.
  bool ComputeOverlap(const Polygon2d &other_polygon,
                      Polygon2d *const overlap_polygon) const;

  // Only compute intersection over union ratio between two convex polygons.
  double ComputeIoU(const Polygon2d &other_polygon) const;

  AABox2d AABoundingBox() const;

  Box2d BoundingBoxWithHeading(const double heading) const;

  Box2d MinAreaBoundingBox() const;

  void ExtremePoints(const double heading, Vec2d *const first,
                     Vec2d *const last) const;

  Polygon2d ExpandByDistance(const double distance) const;

  std::string DebugString() const;

  double min_x() const { return min_x_; }
  double max_x() const { return max_x_; }
  double min_y() const { return min_y_; }
  double max_y() const { return max_y_; }

 protected:
  void BuildFromPoints();
  int Next(int at) const;
  int Prev(int at) const;

  static bool ClipConvexHull(const LineSegment2d &line_segment,
                             std::vector<Vec2d> *const points);

  std::vector<Vec2d> points_;
  int num_points_ = 0;
  std::vector<LineSegment2d> line_segments_;
  bool is_convex_ = false;
  double area_ = 0.0;
  double min_x_ = 0.0;
  double max_x_ = 0.0;
  double min_y_ = 0.0;
  double max_y_ = 0.0;
};

}  // namespace math
}  // namespace common
}  // namespace apollo