basicmergeplanner.h

Go to the documentation of this file.

/********************************************************************************
 * Copyright (C) 2017-2020 German Aerospace Center (DLR). 
 * Eclipse ADORe, Automated Driving Open Research https://eclipse.org/adore
 *
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 
 *
 * Contributors: 
 *   Matthias Nichting - initial API and implementation
 ********************************************************************************/
 
 
#pragma once
#include "decoupled_lflc_planner.h"
#include "basicconstraintsandreferences.h"
#include "lanechangeconstraintsandreferences.h"
#include <adore/view/alane.h>
#include <adore/params/ap_longitudinal_planner.h>
#include <adore/params/ap_lateral_planner.h>
#include <adore/params/ap_tactical_planner.h>
 
 
namespace adore
{
  namespace fun
  {
    template<int K,int P>
    class BasicMergePlanner:public DecoupledLFLCPlanner<K,P>
    {
      private:
        NominalReferenceSpeed nominalReferenceSpeed_;
        BreakAtHorizon breakAtHorizon_;
        CurvatureSpeedLimitPredict curvatureSpeedLimit_;
        LFVSpeedLimit lfvSpeedLimit_;
        DontDriveBackwards dontDriveBackwards_;
        LongitudinalAccelerationConstraint longitudinalAccelerationConstraintUB_;
        LongitudinalAccelerationConstraint longitudinalAccelerationConstraintLB_;
        StopAtNextGoalPoint stopAtNextGoalPoint_;
        AdhereToNextLimitLine stopAtRedLight_;
        AdhereToNextLimitLine stopAtCheckPoint_;
        FollowPrecedingVehicle_BreakingCurve followPrecedingVehicleOnSource_;
        FollowPrecedingVehicle_BreakingCurve followPrecedingVehicleOnTarget_;
        LateralAccelerationReference lateralAccelerationReference_;
        LateralJerkReference lateralJerkReference_;
        HeadingConstraint headingConstraintUB_;
        HeadingConstraint headingConstraintLB_;
        LateralAccelerationConstraint lateralAccelerationConstraintUB_;
        LateralAccelerationConstraint lateralAccelerationConstraintLB_;
        LateralOffsetConstraintLM lateralOffsetConstraint_left_;
        LateralOffsetConstraintLM lateralOffsetConstraint_right_;
        FollowCenterlineReference followCenterlineReference_;
      public:
 
        BasicMergePlanner(   adore::view::ALaneChangeView* lcv,
                                  adore::view::ANavigationGoalView* goalview,
                                  adore::view::ALimitLineEnRoute* controlledConnection,
                                  adore::view::ALimitLineEnRoute* checkpoint,
                                  adore::params::APLongitudinalPlanner* plon,
                                  adore::params::APLateralPlanner* plat,
                                  adore::params::APTacticalPlanner* ptac,
                                  adore::params::APVehicle* pveh,
                                  adore::params::APTrajectoryGeneration* ptrajectory)
              : DecoupledLFLCPlanner<K,P>(lcv->getSourceLane(),plon,plat,pveh,ptrajectory),
                nominalReferenceSpeed_(lcv->getSourceLane(),plon,ptac),
                breakAtHorizon_(lcv->getSourceLane(),pveh,ptrajectory),
                curvatureSpeedLimit_(lcv->getSourceLane(),plon),
                lfvSpeedLimit_(lcv->getSourceLane(),ptac),
                dontDriveBackwards_(),
                longitudinalAccelerationConstraintUB_(plon,ANominalConstraint::UB),
                longitudinalAccelerationConstraintLB_(plon,ANominalConstraint::LB),
                lateralAccelerationReference_(lcv->getSourceLane()),
                lateralJerkReference_(lcv->getSourceLane()),
                followPrecedingVehicleOnSource_(lcv->getSourceLane(),pveh,ptac,ptrajectory),
                followPrecedingVehicleOnTarget_(lcv->getTargetLane(),pveh,ptac,ptrajectory),
                stopAtNextGoalPoint_(goalview),
                stopAtRedLight_(controlledConnection),
                stopAtCheckPoint_(checkpoint),
                headingConstraintUB_(plat,ANominalConstraint::UB),
                headingConstraintLB_(plat,ANominalConstraint::LB),
                lateralAccelerationConstraintUB_(lcv->getSourceLane(),plat,ANominalConstraint::UB),
                lateralAccelerationConstraintLB_(lcv->getSourceLane(),plat,ANominalConstraint::LB),
                lateralOffsetConstraint_left_(lcv,pveh,plat,ANominalConstraint::UB),
                lateralOffsetConstraint_right_(lcv,pveh,plat,ANominalConstraint::LB),
                followCenterlineReference_(lcv->getSourceLane())
        {
          this->info_.add(&nominalReferenceSpeed_);
          this->info_.add(&breakAtHorizon_);
          this->info_.add(&curvatureSpeedLimit_);
          this->info_.add(&lfvSpeedLimit_);
          this->info_.add(&dontDriveBackwards_);
          this->info_.add(&longitudinalAccelerationConstraintUB_);
          this->info_.add(&longitudinalAccelerationConstraintLB_);
          this->info_.add(&followPrecedingVehicleOnSource_);
          this->info_.add(&followPrecedingVehicleOnTarget_);
          this->info_.add(&stopAtNextGoalPoint_);
          this->info_.add(&stopAtRedLight_);
          this->info_.add(&stopAtCheckPoint_);
          this->info_.add(&lateralAccelerationReference_);
          this->info_.add(&lateralJerkReference_);
          this->info_.add(&headingConstraintUB_);
          this->info_.add(&headingConstraintLB_);
          this->info_.add(&lateralAccelerationConstraintUB_);
          this->info_.add(&lateralAccelerationConstraintLB_);
          this->info_.add(&lateralOffsetConstraint_left_);
          this->info_.add(&lateralOffsetConstraint_right_);
          this->info_.add(&followCenterlineReference_);
        }
 
    };
  }
}