polygon2d.h

浏览该文件的文档.

/******************************************************************************
 * 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"
 
namespace apollo {
namespace common {
namespace math {
 
class Polygon2d {
 public:
  Polygon2d() = default;
 
  explicit Polygon2d(const Box2d &box);
 
  explicit Polygon2d(std::vector<Vec2d> points, bool check_area = true);
 
  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 check_area = true);
 
  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;
 
  Polygon2d PolygonExpandByDistance(const double distance) const;
 
  void CalculateVertices(const Vec2d &shift_vec);
 
  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_; }
  LineSegment2d MinLineSegment() const;
 
 protected:
  void BuildFromPoints(bool check_area = true);
  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