box2d.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 <limits>
#include <string>
#include <vector>

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

namespace apollo {
namespace common {
namespace math {

class Box2d {
 public:
  Box2d() = default;
  Box2d(const Vec2d &center, const double heading, const double length,
        const double width);

  Box2d(const LineSegment2d &axis, const double width);

  explicit Box2d(const AABox2d &aabox);

  static Box2d CreateAABox(const Vec2d &one_corner,
                           const Vec2d &opposite_corner);

  const Vec2d &center() const { return center_; }

  double center_x() const { return center_.x(); }

  double center_y() const { return center_.y(); }

  double length() const { return length_; }

  double width() const { return width_; }

  double half_length() const { return half_length_; }

  double half_width() const { return half_width_; }

  double heading() const { return heading_; }

  double cos_heading() const { return cos_heading_; }

  double sin_heading() const { return sin_heading_; }

  double area() const { return length_ * width_; }

  double diagonal() const { return std::hypot(length_, width_); }

  void GetAllCorners(std::vector<Vec2d> *const corners) const;

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

  bool IsPointIn(const Vec2d &point) const;

  bool IsPointOnBoundary(const Vec2d &point) const;

  double DistanceTo(const Vec2d &point) const;

  double DistanceTo(const LineSegment2d &line_segment) const;

  double DistanceTo(const Box2d &box) const;

  bool HasOverlap(const LineSegment2d &line_segment) const;

  bool HasOverlap(const Box2d &box) const;

  AABox2d GetAABox() const;

  void RotateFromCenter(const double rotate_angle);

  void Shift(const Vec2d &shift_vec);

  void LongitudinalExtend(const double extension_length);

  void LateralExtend(const double extension_length);

  std::string DebugString() const;

  void InitCorners();

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

 private:
  Vec2d center_;
  double length_ = 0.0;
  double width_ = 0.0;
  double half_length_ = 0.0;
  double half_width_ = 0.0;
  double heading_ = 0.0;
  double cos_heading_ = 1.0;
  double sin_heading_ = 0.0;

  std::vector<Vec2d> corners_;

  double max_x_ = std::numeric_limits<double>::lowest();
  double min_x_ = std::numeric_limits<double>::max();
  double max_y_ = std::numeric_limits<double>::lowest();
  double min_y_ = std::numeric_limits<double>::max();
};

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