lanefollowingview.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: 
 *   Daniel Heß - initial API and implementation
 *   Matthias Nichting - initial API and implementation
 ********************************************************************************/
 
 
#pragma once
#include <adore/env/afactory.h>
#include <adore/env/borderbased/lanefollowinggeometry.h>
#include <adore/env/borderbased/localroadmap.h>
#include <adore/env/traffic/egolanetraffic.h>
#include <adore/params/afactory.h>
#include <adore/view/alane.h>
#include <adore/env/borderbased/conflictset.h>
//#include <adore/env/traffic/participant.h>
 
 
namespace adore
{
namespace env
 
{
namespace BorderBased
{
class [[deprecated("lanefollowingview is superseded by threelaneviewdecoupled")]] LaneFollowingView : public adore::view::ALane
{
public:
  typedef LaneFollowingGeometry<20, 200> TLaneFollowingGeometry;
 
private:
  LocalRoadMap *lrm_;                         
  TLaneFollowingGeometry lfg_;                
  adore::params::APLaneFollowingView *apLFV_; 
  adore::env::traffic::EgoLaneTraffic elt_;   
  adore::env::BorderBased::ConflictSet cs_;               
public:
 LaneFollowingView(adore::params::AFactory *paramsfactory,
                    LocalRoadMap *localRoadMap,
                    adore::env::traffic::TrafficMap *trafficMap)
      : lrm_(localRoadMap), elt_(trafficMap), cs_(&lfg_)
  {
    apLFV_ = paramsfactory->getLaneFollowingView();
  }
 
  LaneFollowingView(LocalRoadMap *localRoadMap,
                    adore::env::traffic::TrafficMap *trafficMap)
      : LaneFollowingView(adore::params::ParamsFactoryInstance::get(),localRoadMap,trafficMap)
  {}
 
 
 
 
  std::unordered_multimap<view::ConflictZone*, std::vector<Border*>>* getConflictSetPlotData()
  {
    return getConflictSetPlotData();
  }
  [[deprecated("lanefollowingview is superseded by threelaneviewdecoupled")]]
  void update()
  {
    lfg_.update(lrm_->getBorderSet(), lrm_->getBorderTrace(),
                lrm_->getBorderCostMap(), lrm_->getMatchedBorder(),
                lrm_->getVehicleState(), apLFV_->getLookAhead(), apLFV_->getLookBehind(),
                apLFV_->getBaselineFitSmoothness(), lrm_->isNavigationActive());
    elt_.mapVehiclesOnBorders(this, *lfg_.getRightBorders()->getBorders());
    cs_.update(lrm_->getBorderSet(),lrm_->getPrecedenceSet(), &elt_, lfg_.getRightBorders()->getBorders(),lfg_.getLeftBorders()->getBorders());
  }
  LocalRoadMap *getLocalRoadMap() { return lrm_; }
  
 
  void getBordersToPrint(std::vector<Border*> &result,std::vector<int> &ids)
  {
   return cs_.getBordersToPrint(result,ids);
  }
 
 
  TLaneFollowingGeometry *getGeometry() { return &lfg_; }
 
public: // methods from ALane
  virtual bool isValid() const override { return lfg_.isValid(); }
  virtual double getSMax() const override
  {
    return lfg_.getViewingDistance();
  }
  virtual double getSMin() const override
  {
    return 0.0;
  }
  virtual double getProgressOfWidthOpen() const override
  {
      return lfg_.m_s_lane_width_open;
  }
  virtual double getProgressOfWidthClosed() const override
  {
      return lfg_.m_s_lane_width_closed;
  }
  virtual const adore::view::TrafficQueue &getOnLaneTraffic() const override
  {
    return elt_.getQueue();
  }
  virtual const adore::view::ConflictSet &getConflictSet() const override
  {
    return (adore::view::ConflictSet&)cs_;
  }
  [[deprecated("lanefollowingview is superseded by threelaneviewdecoupled")]]
  virtual double getSpeedLimit(double s) override { return 40.0; }
 
  [[deprecated("lanefollowingview is superseded by threelaneviewdecoupled")]]
  virtual double getLeftIndicatorHint(double s) override { return 0.0; }
 
  [[deprecated("lanefollowingview is superseded by threelaneviewdecoupled")]]
  virtual double getRightIndicatorHint(double s) override { return 0.0; }
  virtual bool hasSpeedRecommendation(double s) const override { return false; }
  virtual double getSpeedRecommendation(double s) const override { return 0.0; }
 
  virtual double getNavigationCost(double s) override {return 0.0;}
  virtual void boundNavigationCost(double s0,double s1,double& cmin,double& cmax) override
  {
    cmin = 0.0;cmax = 0.0;
  }
 
public: // methods from ALane
  virtual double getHeading(double s) override { return lfg_.getHeading(s); }
  virtual double getCurvature(double s, int derivative) override
  {
    return lfg_.getCurvature(s, derivative);
  }
  virtual double getOffsetOfLeftBorder(double s) override
  {
    return lfg_.getOffsetOfLeftBorder(s);
  }
  virtual double getOffsetOfRightBorder(double s) override
  {
    return lfg_.getOffsetOfRightBorder(s);
  }
  virtual void toRelativeCoordinates(double xe, double ye, double &s,
                                     double &n) override
  {
    lfg_.toRelativeCoordinates(xe, ye, s, n);
  }
  virtual void toEucledianCoordinates(double s, double n, double &xe,
                                      double &ye, double &ze) override
  {
    lfg_.toEucledianCoordinates(s, n, xe, ye, ze);
  }
 
  std::vector<Coordinate> *getCornerPoints() { return cs_.getCornerPoints(); }
  std::vector<BorderOverlapSet> *getOverlapSet() { return cs_.getOverlapSet(); }
  std::vector<Border *> *get_right_borders_of_conf_lanes()
  {
    return cs_.get_right_borders_of_conf_lanes();
  }
 
  
  
};
} // namespace BorderBased
} // namespace env
} // namespace adore