TrajectoryPedestrian.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2020-2021 Intel Corporation
//
// SPDX-License-Identifier: LGPL-2.1-only
//
// ----------------- END LICENSE BLOCK -----------------------------------
#pragma once
 
#include <ad/geometry/GeometryOperation.hpp>
#include <ad/geometry/Types.hpp>
#include <ad/physics/RatioValue.hpp>
#include "ad/rss/core/RelativeObjectState.hpp"
#include "ad/rss/unstructured/TrajectoryCommon.hpp"
 
namespace ad {
namespace rss {
namespace unstructured {
 
class TrajectoryPedestrian
{
public:
  static const physics::Distance maxRadius;
 
  static const physics::Angle circleStepWidth;
 
  TrajectoryPedestrian()
  {
  }
 
  bool calculateTrajectorySets(core::RelativeObjectState const &vehicleState,
                               ::ad::geometry::Polygon &brakePolygon,
                               ::ad::geometry::Polygon &continueForwardPolygon);
 
private:
  bool getResponseTimeTrajectoryPoints(core::RelativeObjectState const &vehicleState,
                                       TrajectorySetStep &frontSide,
                                       TrajectorySetStep &backSide) const;
 
  bool calculateTrajectoryPoint(TrajectoryPoint &currentPoint,
                                world::RssDynamics const &dynamics,
                                physics::Duration const &duration,
                                ad::physics::Acceleration const &acceleration,
                                ad::physics::RatioValue const &yawRateChangeRatio) const;
 
  void calculateTrajectoryPoint(TrajectoryPoint &currentPoint,
                                world::RssDynamics const &dynamics,
                                physics::Distance const &distance,
                                ad::physics::RatioValue const &angleChangeRatio) const;
 
  void calculateTrajectoryPointStraight(TrajectoryPoint const &currentPoint,
                                        physics::Distance const &distance,
                                        TrajectoryPoint &resultPoint) const;
 
  void calculateTrajectoryPointsStraight(physics::Distance const &distance,
                                         TrajectorySetStep const &step,
                                         TrajectorySetStep &resultStep) const;
 
  ::ad::geometry::Polygon calculateSidePolygon(core::RelativeObjectState const &vehicleState,
                                               TrajectoryPoint const &finalPointMin,
                                               TrajectoryPoint const &finalPointMax) const;
 
  bool calculateTrajectorySetsStandingStill(core::RelativeObjectState const &vehicleState,
                                            physics::Duration const &timeToStop,
                                            ::ad::geometry::Polygon &brakePolygon,
                                            ::ad::geometry::Polygon &continueForwardPolygon) const;
 
  bool calculateTrajectorySetsMoving(core::RelativeObjectState const &vehicleState,
                                     physics::Duration const &timeToStopSpeedMin,
                                     ::ad::geometry::Polygon &brakePolygon,
                                     physics::Duration const &timeToStopSpeedMax,
                                     ::ad::geometry::Polygon &continueForwardPolygon) const;
};
 
} // namespace unstructured
} // namespace rss
} // namespace ad