ADORe
ADORe is a modular open source software library and toolkit for decision making, planning, control and simulation of automated vehicles
basicconstraintsandreferences.h
Go to the documentation of this file.
1 /********************************************************************************
2  * Copyright (C) 2017-2020 German Aerospace Center (DLR).
3  * Eclipse ADORe, Automated Driving Open Research https://eclipse.org/adore
4  *
5  * This program and the accompanying materials are made available under the
6  * terms of the Eclipse Public License 2.0 which is available at
7  * http://www.eclipse.org/legal/epl-2.0.
8  *
9  * SPDX-License-Identifier: EPL-2.0
10  *
11  * Contributors:
12  * Daniel Heß - initial API and implementation
13  ********************************************************************************/
14 
15 #pragma once
19 #include <adore/view/alane.h>
21 #include <adore/params/afactory.h>
22 #include <adore/mad/adoremath.h>
23 #include <set>
24 
25 namespace adore
26 {
27  namespace fun
28  {
34  {
35  private:
38  double lon_ayub_;
39  double vmin_ay_;
40  public:
43  :lfv_(lfv),plon_(plon){}
44 
45  virtual double getValue(double t,double s,double ds)const override
46  {
47  double kappa = (std::abs)(lfv_->getCurvature(s,0));
48  if(kappa<1e-6)return 10000.0;
49  return (std::max)((std::sqrt)(lon_ayub_ / kappa),vmin_ay_);
50  }
51  virtual void update(double t0,double s0,double ds0) override
52  {
55  }
56  virtual ConstraintDirection getDirection() override
57  {
58  return UB;
59  }
60  virtual int getDimension() override
61  {
62  return 0;
63  }
64  virtual int getDerivative() override
65  {
66  return 1;
67  }
68  };
73  {
74  private:
76  double dt;
77  int km;
78  int kp;
79  public:
82  :csl_(lfv,plon)
83  {
84  dt = 0.5;
85  km = 5;
86  kp = 15;
87  }
88 
89  virtual double getValue(double t,double s,double ds)const override
90  {
91  ds = std::max(0.0,ds);
92  double value = csl_.getValue(t,s,ds);
93  for(int i=1;i<=kp;i++)value+=csl_.getValue(t,s+ds*dt*i,ds);
94  for(int i=1;i<=km;i++)value+=csl_.getValue(t,s-ds*dt*i,ds);
95  value = value / (double)(kp+km+1);
96  return value;
97  }
98  virtual void update(double t0,double s0,double ds0) override
99  {
100  csl_.update(t0,s0,ds0);
101  }
103  {
104  return UB;
105  }
106  virtual int getDimension() override
107  {
108  return 0;
109  }
110  virtual int getDerivative() override
111  {
112  return 1;
113  }
114  };
119  {
120  private:
122  double sstep_;
123  double smax_;
125  double a;
127 
128  public:
131  :csl_(lfv,plon),plon_(plon)
132  {
133  sstep_ = 1.0;
134  smax_ = 200.0;
135  s_curvature_lookahead_ = 10.0;
136  }
137 
138  virtual double getValue(double t,double s,double ds)const override
139  {
140  ds = std::max(0.0,ds);
141  const double t_lah = ds/a;
142  const double s_lah = (std::min)(smax_,0.5*a*t_lah*t_lah);//breaking distance at current speed
143  double vmin = csl_.getValue(t,s,ds);//init with current limit
144  for(double si = s+sstep_;si<=s+s_lah;si+=sstep_)
145  {
146  double v1 = csl_.getValue(t,si,ds);
147  for(double sj = si + sstep_;sj<=si+s_curvature_lookahead_;sj+=sstep_)
148  {
149  v1 = (std::min)(v1,csl_.getValue(t,sj,ds));
150  }
151  const double v0 = std::sqrt(v1*v1+2.0*(si-s)*a);//initial velocity of breaking curve arriving at si with v1
152  vmin = (std::min)(vmin,v0);
153  }
154  return std::max(0.0,vmin);
155  }
156  virtual void update(double t0,double s0,double ds0) override
157  {
158  a = -plon_->getComfortAccLB();
159  csl_.update(t0,s0,ds0);
160  }
162  {
163  return UB;
164  }
165  virtual int getDimension() override
166  {
167  return 0;
168  }
169  virtual int getDerivative() override
170  {
171  return 1;
172  }
173  };
178  {
179  public:
181  virtual double getValue(double t,double s,double ds)const override
182  {
183  return 0.0;
184  }
185  virtual void update(double t0,double s0,double ds0) override {}
187  {
188  return LB;
189  }
190  virtual int getDimension() override
191  {
192  return 0;
193  }
194  virtual int getDerivative() override
195  {
196  return 1;
197  }
198  };
203  {
204  private:
212  public:
215  :lfv_(lfv),plon_(plon){}
216 
217  virtual double getValue(double t,double s,double ds)const override
218  {
220  if(d>min_width_fast_)
221  {
222  return 10000.0;
223  }
224  else if(d>min_width_slow_)
225  {
226  return min_width_slow_speed_
227  + (d-min_width_slow_)
230  }
231  else
232  {
233  return std::max(0.0,(d-min_width_stop_)
236  }
237 
238  }
239  virtual void update(double t0,double s0,double ds0) override
240  {
246  }
248  {
249  return UB;
250  }
251  virtual int getDimension() override
252  {
253  return 0;
254  }
255  virtual int getDerivative() override
256  {
257  return 1;
258  }
259  };
264  {
265  private:
271  double distance_;
272  double ds_sample_;
273  public:
276  const adore::params::APVehicle* pv,
279  :lfv_(lfv),plon_(plon),pv_(pv),pgen_(pgen),ptac_(ptac)
280  {
281  ds_sample_ = 1.0;
282  }
283  virtual double getValue(double t,double s,double ds)const override
284  {
285  return distance_;
286  }
287  virtual void update(double t0,double s0,double ds0) override
288  {
289  distance_ = lfv_->getSMax()
290  - pv_->get_a()-pv_->get_b()-pv_->get_c()
291  + pgen_->get_rho();
292  double dmin = plon_->getMinWidthStop();
293  for(double s = s0;s<lfv_->getSMax();s+=ds_sample_)
294  {
296  if(d<=dmin)
297  {
298  distance_ = s - pv_->get_a()-pv_->get_b()-pv_->get_c()
300  break;
301  }
302  }
303  }
305  {
306  return UB;
307  }
308  virtual int getDimension() override
309  {
310  return 0;
311  }
312  virtual int getDerivative() override
313  {
314  return 0;
315  }
316  };
317 
318 
323  {
324  private:
328  double distance_;
329  public:
331  lfv_(lfv),pvehicle_(pvehicle),pgen_(pgen){}
332  virtual double getValue(double t,double s,double ds)const override
333  {
334  return distance_;
335  }
336  virtual void update(double t0,double s0,double ds0) override
337  {
339  }
341  {
342  return UB;
343  }
344  virtual int getDimension() override
345  {
346  return 0;
347  }
348  virtual int getDerivative() override
349  {
350  return 0;
351  }
352  };
353 
354 
355 
361  {
362  private:
365  double ay_ub_;
366  double ay_lb_;
370  public:
374  :lfv_(lfv),p_(p),d_(d){}
375 
376  virtual double getValue(double t,double s,double ds)const override
377  {
378  double kappa = lfv_->getCurvature(s,0);
379  ds = (std::max)(0.0,ds);
380  double ayset = -kappa*ds*ds;
381  return ayset + (d_==LB?(std::max)(curvature_lb_*ds*ds,ay_lb_)
382  :(std::min)(curvature_ub_*ds*ds,ay_ub_));
383  }
384  virtual void update(double t0,double s0,double ds0) override
385  {
386  ay_lb_ = p_->getAccLB();
387  ay_ub_ = p_->getAccUB();
390  }
392  {
393  return d_;
394  }
395  virtual int getDimension() override
396  {
397  return 1;
398  }
399  virtual int getDerivative() override
400  {
401  return 2;
402  }
403  };
404 
409  {
410  private:
412  double heading_ub_;
413  double heading_lb_;
415  public:
418  :p_(p),d_(d){}
419 
420  virtual double getValue(double t,double s,double ds)const override
421  {
422  ds = std::max(0.001,ds);
423  return ds * (std::tan)(d_==LB?heading_lb_:heading_ub_);
424  }
425  virtual void update(double t0,double s0,double ds0) override
426  {
429  }
431  {
432  return d_;
433  }
434  virtual int getDimension() override
435  {
436  return 1;
437  }
438  virtual int getDerivative() override
439  {
440  return 1;
441  }
442  };
443 
453  {
454  private:
459  double amin_;
460  double t0_;
461  double ds0_;
462  public:
464  {
465  globalSpeedLimit_ = 5.0;
466  amin_ = -1.0;
467  t0_ = 0.0;
469  }
470 
471  virtual double getValue(double t,double s,double ds)const override
472  {
473  double v_initially_constrained = ds0_ + amin_*(t-t0_);
474  double v_limit = std::min(lfv_->getSpeedLimit(s),globalSpeedLimit_);
475  return std::max(v_initially_constrained,v_limit);
476  }
477 
478  virtual void update(double t0,double s0,double ds0) override
479  {
482  t0_ = t0;
483  ds0_ = ds0;
484  }
486  {
487  return UB;
488  }
489  virtual int getDimension() override
490  {
491  return 0;
492  }
493  virtual int getDerivative() override
494  {
495  return 1;
496  }
497  };
498 
499 
504  {
505  private:
511  double distance_;
512  public:
515  lfv_(lfv),pvehicle_(pvehicle),pgen_(pgen), ptac_(ptac) {
516  }
517 
518  void update(double t0,double s0,double ds0) override
519  {
522  }
523  virtual double getValue(double t,double s,double ds)const override
524  {
525  return distance_;
526  }
528  {
529  return UB;
530  }
531  virtual int getDimension() override
532  {
533  return 0;
534  }
535  virtual int getDerivative() override
536  {
537  return 0;
538  }
539  };
540 
541 
542 
547  {
548  private:
550  public:
552  public:
553  virtual bool getValueIfAvailable(double t, double s, double ds,double & ref)const override
554  {
555  ds = std::max(0.0,ds);
556  double kappa = lfv_->getCurvature(s,0);
557  ref = -kappa*ds*ds;
558  return true;
559  }
560  virtual void update(double t0,double s0,double ds0)override{}
561  virtual int getDimension() override
562  {
563  return 1;
564  }
565  virtual int getDerivative() override
566  {
567  return 2;
568  }
569  };
570 
575  {
576  private:
578  public:
580  public:
581  virtual bool getValueIfAvailable(double t, double s, double ds,double & ref)const override
582  {
583  ds = std::max(0.0,ds);
584  double dkappads = lfv_->getCurvature(s,1);
585  ref = -dkappads*ds*ds*ds;
586  return true;
587  }
588  virtual void update(double t0,double s0,double ds0)override{}
589  virtual int getDimension() override
590  {
591  return 1;
592  }
593  virtual int getDerivative() override
594  {
595  return 3;
596  }
597  };
598 
603  {
604  private:
610  double speed_scale_;
611  public:
613  :lfv_(lfv),lFVSpeedLimit_(lfv,ptac),curvatureSpeedLimit_(lfv,plon),plon_(plon)
614  {
615  speed_scale_ = 1.0;
616  }
617  public:
618  virtual bool getValueIfAvailable(double t, double s, double ds,double & ref)const override
619  {
620  //set reference to upper bound - constraint clearance parameter
621  ref = (std::max)(0.0,(std::min)(lFVSpeedLimit_.getValue(t,s,ds),
624  return true;
625  }
626  void setSpeedScale(double value)
627  {
628  speed_scale_ = value;
629  }
630  virtual void update(double t0,double s0,double ds0)override
631  {
633  lFVSpeedLimit_.update(t0,s0,ds0);
634  curvatureSpeedLimit_.update(t0,s0,ds0);
635  }
636  virtual int getDimension() override
637  {
638  return 0;
639  }
640  virtual int getDerivative() override
641  {
642  return 1;
643  }
644  };
645 
650  {
651  private:
655  double d_;
656  double dmax_;
657  double w_;
658  double i_grid_;//grid step index
659  public:
660  FollowCenterlineReference(adore::view::ALane* lfv,double i_grid = 0.0):lfv_(lfv)
661  {
664  d_ = 0.2;
665  dmax_ = 0;
666  w_ = 1.8;
667  i_grid_ = i_grid;//You don't know nothing, Jon Snow!
668  }
669  virtual bool getValueIfAvailable(double t, double s, double ds,double & ref)const override
670  {
671  const double dl = lfv_->getOffsetOfLeftBorder(s)-dmax_-w_*0.5;
672  const double dr = lfv_->getOffsetOfRightBorder(s)+dmax_+w_*0.5;
673  const double dc = (dl+dr)*0.5;
674  ref = dc + i_grid_ * d_;
675  if(dl<ref && ref<dr)ref = dc;//constraints invalid, use center
676  else if(dl<ref)ref = dl;
677  else if(ref<dr)ref = dr;
678  return true;
679  }
680  virtual void update(double t0,double s0,double ds0)override
681  {
684  w_ = p_veh_->get_bodyWidth();
685  }
686  virtual int getDimension() override
687  {
688  return 1;
689  }
690  virtual int getDerivative() override
691  {
692  return 0;
693  }
694  };
695 
700  {
701  private:
705  double width_;
709  double delay_s_;
710  double delay_n_;
711  double s0_;
713  public:
717  ConstraintDirection d):lfv_(lfv),pv_(pv),plat_(plat),d_(d)
718  {
719  }
720 
721 
722  double getValue(double t,double s,double ds)const override
723  {
724  double dl = lfv_->getOffsetOfLeftBorder(s);
725  double dr = lfv_->getOffsetOfRightBorder(s);
726  double dc = (dl+dr)*0.5;
727  if(s-s0_<delay_s_)
728  {
729  dl += delay_n_;
730  dr -= delay_n_;
731  }
732  double d = dl-dr;
733 
734  //TODO: next section was added for debugging
735  {
736  if(d_==LB)
737  {
738  return dr + hard_safety_distance_ + width_*0.5;
739  }
740  else
741  {
742  return dl - hard_safety_distance_ - width_*0.5;
743  }
744  }
745 
746  //not enough room to enforce hard safety distance->singular solution
747  if(d < 2.0*hard_safety_distance_ + width_)
748  {
749  return dc+((d_==LB)?-0.01:+0.01);
750  }
751  //not enough room to enforce min_control_space and hard_safety_distance -> enforce hard_safety_distance
752  else if(d < 2.0*soft_safety_distance_ + width_ + min_control_space_)
753  {
754  if(d_==LB)
755  {
756  return dr + hard_safety_distance_ + width_*0.5;
757  }
758  else
759  {
760  return dl - hard_safety_distance_ - width_*0.5;
761  }
762  }
763  //enough room to enforce soft_safety_distance and min_control_space
764  else
765  {
766  if(d_==LB)
767  {
768  return dr + soft_safety_distance_ + width_*0.5;
769  }
770  else
771  {
772  return dl - soft_safety_distance_ - width_*0.5;
773  }
774  }
775  }
776  virtual void update(double t0,double s0,double ds0) override
777  {
778  width_ = pv_->get_bodyWidth();
783  delay_n_ = width_;
784  s0_ = s0;
785  }
787  {
788  return d_;
789  }
790  virtual int getDimension() override
791  {
792  return 1;
793  }
794  virtual int getDerivative() override
795  {
796  return 0;
797  }
798  };
799 
804  {
805  private:
807  double ax_ub_;
808  double ax_lb_;
809  double ax_ub_slow_;
811  double ds0_;
812  double t0_;
814  public:
817  :plon_(plon),d_(d){}
818 
819  virtual double getValue(double t,double s,double ds)const override
820  {
822  {
823  return ax_lb_;
824  }
825  else
826  {
827  double daxdds = std::max(0.0,(ax_ub_slow_-ax_ub_)/std::max(0.1,v_ax_ub_slow_));
828  return ax_ub_slow_ - std::max(0.0,std::min(v_ax_ub_slow_,ds)) * daxdds;
829  }
830  }
831  virtual void update(double t0,double s0,double ds0) override
832  {
833  ax_ub_ = plon_->getAccUB();
834  ax_lb_ = plon_->getAccLB();
837  t0_ = t0;
838  ds0_ = ds0;
839  }
841  {
842  return d_;
843  }
844  virtual int getDimension() override
845  {
846  return 0;
847  }
848  virtual int getDerivative() override
849  {
850  return 2;
851  }
852  };
853 
858  {
859  private:
864  //@TODO: prediction strategy
865  double s_front_t0_;
866  double v_front_t0_;
867  double t0_;
868  public:
870  const adore::params::APVehicle* pveh,
873  :lane_(lane),ptac_(ptac),pveh_(pveh),pgen_(pgen){}
874  virtual double getValue(double t,double s,double ds)const override
875  {
876  return s_front_t0_ + v_front_t0_ * (t-t0_);
877  }
878  virtual void update(double t0,double s0,double ds0) override
879  {
880  double to_front = pveh_->get_a() + pveh_->get_b() + pveh_->get_c() - pgen_->get_rho();
882  s_front_t0_ = 1.0e6;//initialize unbounded
883  v_front_t0_ = 0.0;
884  t0_ = t0;
885  for(auto& object:q)
886  {
887  double object_v0 = object.getCurrentSpeed();
888  double delay = t0_ - object.getObservationTime();
889  double object_s0 = object.getCurrentProgress() - object.getLength()*0.5 - to_front + delay * object_v0;
890  if(object_s0>s0)
891  {
892  double buffer = object_v0 * ptac_->getFrontTimeGap() + ptac_->getFrontSGap();
893  s_front_t0_ = object_s0 - buffer ;
894  v_front_t0_ = object_v0;
895  break;
896  }
897  }
898  }
900  {
901  return UB;
902  }
903  virtual int getDimension() override
904  {
905  return 0;
906  }
907  virtual int getDerivative() override
908  {
909  return 0;
910  }
911  };
912 
917  {
918  private:
923  //@TODO: prediction strategy
924  double s_front_t0_;
925  double v_front_t0_;
926  double t0_;
927  double amin_;
928  public:
930  const adore::params::APVehicle* pveh,
933  :lane_(lane),ptac_(ptac),pveh_(pveh),pgen_(pgen),amin_(-1.0){}
934  virtual double getValue(double t,double s,double ds)const override
935  {
936  double t_standstill = std::max(v_front_t0_,0.0) / -amin_ + t0_;
937  t = std::min(t,t_standstill);//predict no further then until standstill
938  return s_front_t0_ + v_front_t0_ * (t-t0_) + 0.5*amin_*(t-t0_)*(t-t0_);
939  }
940  virtual void update(double t0,double s0,double ds0) override
941  {
943  double to_front = pveh_->get_a() + pveh_->get_b() + pveh_->get_c() - pgen_->get_rho();
945  s_front_t0_ = 1.0e6;//initialize unbounded
946  v_front_t0_ = 0.0;
947  t0_ = t0;
948  for(auto& object:q)
949  {
950  double object_v0 = object.getCurrentSpeed();
951  double delay = t0_ - object.getObservationTime();
952  double object_s0 = object.getCurrentProgress() - object.getLength()*0.5 - to_front + delay * object_v0;
953  if(object_s0>s0)
954  {
955  //in contrast to other constraint variant, the time gap is removed here, as the breaking curve is directly considered
956  double buffer = ptac_->getFrontSGap();
957  s_front_t0_ = object_s0 - buffer ;
958  v_front_t0_ = object_v0;
959  break;
960  }
961  }
962  }
964  {
965  return UB;
966  }
967  virtual int getDimension() override
968  {
969  return 0;
970  }
971  virtual int getDerivative() override
972  {
973  return 0;
974  }
975  };
976 
982  {
983  private:
988  //@TODO: prediction strategy
989  double s_front_t0_;
990  double v_front_t0_;
991  double t0_;
992  double amin_;
993  public:
995  const adore::params::APVehicle* pveh,
998  :lane_(lane),ptac_(ptac),pveh_(pveh),pgen_(pgen),amin_(-1.0){}
999  virtual double getValue(double t,double s,double ds)const override
1000  {
1001  return s_front_t0_ + v_front_t0_ * (t-t0_);
1002  }
1003  virtual void update(double t0,double s0,double ds0) override
1004  {
1005  double to_front = pveh_->get_a() + pveh_->get_b() + pveh_->get_c() - pgen_->get_rho();
1007  s_front_t0_ = 1.0e6;//initialize unbounded
1008  v_front_t0_ = 0.0;
1009  t0_ = t0;
1010  for(auto& object:q)
1011  {
1012  double object_v0 = object.getCurrentSpeed();
1013  double delay = t0_ - object.getObservationTime();
1014  double object_s0 = object.getCurrentProgress() - object.getLength()*0.5 - to_front + delay * object_v0;
1015  if(object_s0>s0)
1016  {
1017  //in contrast to other constraint variant, the time gap is removed here, as the breaking curve is directly considered
1018  double buffer = ptac_->getLowerBoundFrontSGapForLF();
1019  s_front_t0_ = object_s0 - buffer ;
1020  v_front_t0_ = object_v0;
1021  break;
1022  }
1023  }
1024  }
1026  {
1027  return UB;
1028  }
1029  virtual int getDimension() override
1030  {
1031  return 0;
1032  }
1033  virtual int getDerivative() override
1034  {
1035  return 0;
1036  }
1037  };
1038 
1043  {
1044  private:
1050  double s_max_;
1051  std::set<adore::view::LimitLine::EState> drivable_states_;
1052  std::set<adore::view::LimitLine::EState> clearance_states_;
1053 
1054  public:
1056  :nextLL_(nextLL)
1057  {
1065  drivable_states_.insert(adore::view::LimitLine::dark);//HeD20220407: Usage in DE-BS-Steinriedendamm/Forstrstr intersection: Train crossing pre-signal is "dark", when no trains approaching. AV has to cross pre-signal in that case.
1068  }
1069  virtual double getValue(double t,double s,double ds)const override
1070  {
1071  return s_max_;
1072  }
1073  virtual void update(double t0,double s0,double ds0) override
1074  {
1075  s_max_ = 1.0e6;//initialize unconstrained
1076  if(nextLL_!=nullptr && nextLL_->hasLimitLine(s0))
1077  {
1078  auto ll = nextLL_->getLimitLine(t0,s0);
1079  double front_length = pveh_->get_a() + pveh_->get_b() + pveh_->get_c() - pgen_->get_rho();
1080  double s_stop = ll.getProgress()-front_length;
1081  double distance = s_stop -s0;
1082  double v = ds0>1.0?ds0:0.0;
1083  bool braking_possible = true;
1085  {
1086  //if red light is before rear-bumper: stop
1087  braking_possible = (ll.getProgress()>s0-pgen_->get_rho()-pveh_->get_d());
1088  }
1089  else
1090  {
1091  //prevent braking, if impossible acceleration required
1092  if(v>0.1)
1093  {
1094  double a_stop = -0.5 * v*v / std::max(distance + plon_->stopAtRedLights_max_connection_length(),0.0);
1095  braking_possible = a_stop>plon_->getAccLB();
1096  }
1097  }
1098  //if the current state is drivable
1099  if(drivable_states_.find(ll.getCurrentState())!=drivable_states_.end())
1100  {
1101  return;//leave smax at maximum value
1102  }
1103  //if the red-light is so far behind, that stopping is supressed, continue
1105  {
1106  return;//leave smax at maximum value
1107  }
1108  if(clearance_states_.find(ll.getCurrentState())!=clearance_states_.end()
1109  && !braking_possible)
1110  {
1111  return;//leave smax at maximum value
1112  }
1113  s_max_ = s_stop;
1114  }
1115  }
1117  {
1118  return UB;
1119  }
1120  virtual int getDimension() override
1121  {
1122  return 0;
1123  }
1124  virtual int getDerivative() override
1125  {
1126  return 0;
1127  }
1128  };
1133  {
1134  private:
1138  double s_max_;
1139  public:
1141  :next_(next)
1142  {
1145  }
1146  virtual double getValue(double t,double s,double ds)const override
1147  {
1148  return s_max_;
1149  }
1150  virtual void update(double t0,double s0,double ds0) override
1151  {
1152  s_max_ = 1.0e6;//initialize unconstrained
1153  if(next_!=nullptr
1156  {
1157  double front_length = pveh_->get_a() + pveh_->get_b() + pveh_->get_c() - pgen_->get_rho();
1158  s_max_ = next_->getProgress() - front_length;
1159  }
1160  }
1162  {
1163  return UB;
1164  }
1165  virtual int getDimension() override
1166  {
1167  return 0;
1168  }
1169  virtual int getDerivative() override
1170  {
1171  return 0;
1172  }
1173  };
1174 
1179  {
1180  private:
1183  double smax_;
1186 
1187  public:
1189  {
1190  conflicts_ = conflicts;
1191  }
1193  :conflicts_(conflicts)
1194  {
1195  distance_to_point_ = 5.0;
1198  }
1199  virtual double getValue(double t,double s,double ds)const override
1200  {
1201  return smax_;
1202  }
1203  virtual void update(double t0,double s0,double ds0) override
1204  {
1206  smax_ = 1.0e6;//initialize unconstrained
1207  if(conflicts_!=nullptr && conflicts_->size()>0)
1208  {
1209  auto p = conflicts_->getPoint(0);
1211  }
1212  }
1214  {
1215  return UB;
1216  }
1217  virtual int getDimension() override
1218  {
1219  return 0;
1220  }
1221  virtual int getDerivative() override
1222  {
1223  return 0;
1224  }
1225  };
1226 
1227  }
1228 }
Definition: anominalplanner.h:52
ConstraintDirection
Definition: anominalplanner.h:55
@ LB
Definition: anominalplanner.h:56
@ UB
Definition: anominalplanner.h:56
Definition: anominalplanner.h:96
Definition: basicconstraintsandreferences.h:1043
adore::view::ALimitLineEnRoute * nextLL_
Definition: basicconstraintsandreferences.h:1045
const adore::params::APTacticalPlanner * ptac_
Definition: basicconstraintsandreferences.h:1046
const adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:1049
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:1116
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:1069
double s_max_
Definition: basicconstraintsandreferences.h:1050
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:1120
std::set< adore::view::LimitLine::EState > clearance_states_
Definition: basicconstraintsandreferences.h:1052
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:1073
AdhereToNextLimitLine(adore::view::ALimitLineEnRoute *nextLL)
Definition: basicconstraintsandreferences.h:1055
const adore::params::APVehicle * pveh_
Definition: basicconstraintsandreferences.h:1047
std::set< adore::view::LimitLine::EState > drivable_states_
Definition: basicconstraintsandreferences.h:1051
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:1124
const adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:1048
Definition: basicconstraintsandreferences.h:323
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:340
double distance_
Definition: basicconstraintsandreferences.h:328
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:344
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:332
adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:327
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:325
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:336
adore::params::APVehicle * pvehicle_
Definition: basicconstraintsandreferences.h:326
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:348
BreakAtHorizon(adore::view::ALane *lfv, adore::params::APVehicle *pvehicle, adore::params::APTrajectoryGeneration *pgen)
Definition: basicconstraintsandreferences.h:330
Definition: basicconstraintsandreferences.h:119
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:169
double a
Definition: basicconstraintsandreferences.h:125
CurvatureSpeedLimitPredict(adore::view::ALane *lfv, adore::params::APLongitudinalPlanner *plon)
Definition: basicconstraintsandreferences.h:129
double smax_
Definition: basicconstraintsandreferences.h:123
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:161
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:165
CurvatureSpeedLimit csl_
Definition: basicconstraintsandreferences.h:121
double s_curvature_lookahead_
Definition: basicconstraintsandreferences.h:124
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:138
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:156
double sstep_
Definition: basicconstraintsandreferences.h:122
adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:126
Definition: basicconstraintsandreferences.h:73
CurvatureSpeedLimitSmooth(adore::view::ALane *lfv, adore::params::APLongitudinalPlanner *plon)
Definition: basicconstraintsandreferences.h:80
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:102
CurvatureSpeedLimit csl_
Definition: basicconstraintsandreferences.h:75
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:98
int km
Definition: basicconstraintsandreferences.h:77
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:89
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:110
int kp
Definition: basicconstraintsandreferences.h:78
double dt
Definition: basicconstraintsandreferences.h:76
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:106
Definition: basicconstraintsandreferences.h:34
double lon_ayub_
Definition: basicconstraintsandreferences.h:38
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:45
CurvatureSpeedLimit(adore::view::ALane *lfv, adore::params::APLongitudinalPlanner *plon)
Definition: basicconstraintsandreferences.h:41
adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:37
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:51
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:36
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:56
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:64
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:60
double vmin_ay_
Definition: basicconstraintsandreferences.h:39
Definition: basicconstraintsandreferences.h:504
double stopDistance_
Definition: basicconstraintsandreferences.h:510
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:523
adore::params::APVehicle * pvehicle_
Definition: basicconstraintsandreferences.h:507
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:535
void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:518
adore::params::APTacticalPlanner * ptac_
Definition: basicconstraintsandreferences.h:509
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:506
adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:508
double distance_
Definition: basicconstraintsandreferences.h:511
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:531
DistanceToLaneEndConstraint(adore::view::ALane *lfv, adore::params::APVehicle *pvehicle, adore::params::APTrajectoryGeneration *pgen, adore::params::APTacticalPlanner *ptac)
Definition: basicconstraintsandreferences.h:513
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:527
Definition: basicconstraintsandreferences.h:178
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:185
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:181
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:194
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:186
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:190
DontDriveBackwards()
Definition: basicconstraintsandreferences.h:180
Definition: basicconstraintsandreferences.h:650
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:690
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:652
virtual bool getValueIfAvailable(double t, double s, double ds, double &ref) const override
Definition: basicconstraintsandreferences.h:669
FollowCenterlineReference(adore::view::ALane *lfv, double i_grid=0.0)
Definition: basicconstraintsandreferences.h:660
double w_
hard safety distance
Definition: basicconstraintsandreferences.h:657
double i_grid_
width of vehicle
Definition: basicconstraintsandreferences.h:658
adore::params::APVehicle * p_veh_
Definition: basicconstraintsandreferences.h:654
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:680
double d_
Definition: basicconstraintsandreferences.h:655
adore::params::APLateralPlanner * p_lat_
Definition: basicconstraintsandreferences.h:653
double dmax_
lateral grid scale
Definition: basicconstraintsandreferences.h:656
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:686
Definition: basicconstraintsandreferences.h:917
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:934
double t0_
Definition: basicconstraintsandreferences.h:926
const adore::params::APTacticalPlanner * ptac_
Definition: basicconstraintsandreferences.h:920
double amin_
Definition: basicconstraintsandreferences.h:927
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:963
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:971
FollowPrecedingVehicle_BreakingCurve(adore::view::ALane *lane, const adore::params::APVehicle *pveh, const adore::params::APTacticalPlanner *ptac, const adore::params::APTrajectoryGeneration *pgen)
Definition: basicconstraintsandreferences.h:929
double s_front_t0_
Definition: basicconstraintsandreferences.h:924
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:940
double v_front_t0_
Definition: basicconstraintsandreferences.h:925
adore::view::ALane * lane_
Definition: basicconstraintsandreferences.h:919
const adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:922
const adore::params::APVehicle * pveh_
Definition: basicconstraintsandreferences.h:921
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:967
Definition: basicconstraintsandreferences.h:858
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:903
double s_front_t0_
Definition: basicconstraintsandreferences.h:865
const adore::params::APVehicle * pveh_
Definition: basicconstraintsandreferences.h:862
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:878
const adore::params::APTacticalPlanner * ptac_
Definition: basicconstraintsandreferences.h:861
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:899
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:907
double v_front_t0_
Definition: basicconstraintsandreferences.h:866
const adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:863
adore::view::ALane * lane_
Definition: basicconstraintsandreferences.h:860
double t0_
Definition: basicconstraintsandreferences.h:867
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:874
FollowPrecedingVehicle(adore::view::ALane *lane, const adore::params::APVehicle *pveh, const adore::params::APTacticalPlanner *ptac, const adore::params::APTrajectoryGeneration *pgen)
Definition: basicconstraintsandreferences.h:869
Definition: basicconstraintsandreferences.h:409
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:438
double heading_lb_
Definition: basicconstraintsandreferences.h:413
ConstraintDirection d_
Definition: basicconstraintsandreferences.h:414
adore::params::APLateralPlanner * p_
Definition: basicconstraintsandreferences.h:411
double heading_ub_
Definition: basicconstraintsandreferences.h:412
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:420
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:434
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:430
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:425
HeadingConstraint(adore::params::APLateralPlanner *p, ConstraintDirection d)
Definition: basicconstraintsandreferences.h:416
Definition: basicconstraintsandreferences.h:453
double globalSpeedLimit_
Definition: basicconstraintsandreferences.h:458
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:478
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:489
double t0_
Definition: basicconstraintsandreferences.h:460
adore::params::APTacticalPlanner * p_
Definition: basicconstraintsandreferences.h:456
adore::params::APLongitudinalPlanner * p_long_
Definition: basicconstraintsandreferences.h:457
LFVSpeedLimit(adore::view::ALane *lfv, adore::params::APTacticalPlanner *p)
Definition: basicconstraintsandreferences.h:463
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:493
double ds0_
Definition: basicconstraintsandreferences.h:461
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:485
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:455
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:471
double amin_
Definition: basicconstraintsandreferences.h:459
Definition: basicconstraintsandreferences.h:203
double min_width_slow_speed_
Definition: basicconstraintsandreferences.h:209
double min_width_fast_speed_
Definition: basicconstraintsandreferences.h:211
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:205
double min_width_fast_
Definition: basicconstraintsandreferences.h:210
double min_width_stop_
Definition: basicconstraintsandreferences.h:207
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:251
LaneWidthSpeedLimitLFV(adore::view::ALane *lfv, const adore::params::APLongitudinalPlanner *plon)
Definition: basicconstraintsandreferences.h:213
double min_width_slow_
Definition: basicconstraintsandreferences.h:208
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:239
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:217
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:247
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:255
const adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:206
Definition: basicconstraintsandreferences.h:361
double curvature_lb_
Definition: basicconstraintsandreferences.h:368
LateralAccelerationConstraint(adore::view::ALane *lfv, adore::params::APLateralPlanner *p, ConstraintDirection d)
Definition: basicconstraintsandreferences.h:371
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:384
double ay_lb_
Definition: basicconstraintsandreferences.h:366
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:395
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:363
double ay_ub_
Definition: basicconstraintsandreferences.h:365
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:376
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:391
ConstraintDirection d_
Definition: basicconstraintsandreferences.h:369
double curvature_ub_
Definition: basicconstraintsandreferences.h:367
adore::params::APLateralPlanner * p_
Definition: basicconstraintsandreferences.h:364
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:399
Definition: basicconstraintsandreferences.h:547
virtual bool getValueIfAvailable(double t, double s, double ds, double &ref) const override
Definition: basicconstraintsandreferences.h:553
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:549
LateralAccelerationReference(adore::view::ALane *lfv)
Definition: basicconstraintsandreferences.h:551
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:565
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:560
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:561
Definition: basicconstraintsandreferences.h:575
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:577
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:593
virtual bool getValueIfAvailable(double t, double s, double ds, double &ref) const override
Definition: basicconstraintsandreferences.h:581
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:589
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:588
LateralJerkReference(adore::view::ALane *lfv)
Definition: basicconstraintsandreferences.h:579
Definition: basicconstraintsandreferences.h:700
double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:722
adore::params::APLateralPlanner * plat_
Definition: basicconstraintsandreferences.h:704
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:794
double s0_
Definition: basicconstraintsandreferences.h:711
double soft_safety_distance_
Definition: basicconstraintsandreferences.h:707
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:776
double width_
Definition: basicconstraintsandreferences.h:705
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:702
adore::params::APVehicle * pv_
Definition: basicconstraintsandreferences.h:703
double min_control_space_
Definition: basicconstraintsandreferences.h:708
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:790
double delay_s_
Definition: basicconstraintsandreferences.h:709
double hard_safety_distance_
Definition: basicconstraintsandreferences.h:706
ConstraintDirection d_
Definition: basicconstraintsandreferences.h:712
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:786
double delay_n_
Definition: basicconstraintsandreferences.h:710
LateralOffsetConstraintLF(adore::view::ALane *lfv, adore::params::APVehicle *pv, adore::params::APLateralPlanner *plat, ConstraintDirection d)
Definition: basicconstraintsandreferences.h:714
Definition: basicconstraintsandreferences.h:804
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:848
adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:806
double v_ax_ub_slow_
Definition: basicconstraintsandreferences.h:810
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:831
double ds0_
Definition: basicconstraintsandreferences.h:811
double t0_
Definition: basicconstraintsandreferences.h:812
ANominalConstraint::ConstraintDirection d_
Definition: basicconstraintsandreferences.h:813
double ax_ub_
Definition: basicconstraintsandreferences.h:807
LongitudinalAccelerationConstraint(adore::params::APLongitudinalPlanner *plon, ANominalConstraint::ConstraintDirection d)
Definition: basicconstraintsandreferences.h:815
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:840
double ax_ub_slow_
Definition: basicconstraintsandreferences.h:809
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:844
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:819
double ax_lb_
Definition: basicconstraintsandreferences.h:808
Definition: basicconstraintsandreferences.h:982
LowerBoundSGapToPrecedingVehicle(adore::view::ALane *lane, const adore::params::APVehicle *pveh, const adore::params::APTacticalPlanner *ptac, const adore::params::APTrajectoryGeneration *pgen)
Definition: basicconstraintsandreferences.h:994
double t0_
Definition: basicconstraintsandreferences.h:991
adore::view::ALane * lane_
Definition: basicconstraintsandreferences.h:984
const adore::params::APTacticalPlanner * ptac_
Definition: basicconstraintsandreferences.h:985
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:1003
double amin_
Definition: basicconstraintsandreferences.h:992
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:1025
double s_front_t0_
Definition: basicconstraintsandreferences.h:989
const adore::params::APVehicle * pveh_
Definition: basicconstraintsandreferences.h:986
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:1033
double v_front_t0_
Definition: basicconstraintsandreferences.h:990
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:1029
const adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:987
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:999
Definition: basicconstraintsandreferences.h:603
NominalReferenceSpeed(adore::view::ALane *lfv, adore::params::APLongitudinalPlanner *plon, adore::params::APTacticalPlanner *ptac)
Definition: basicconstraintsandreferences.h:612
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:636
virtual bool getValueIfAvailable(double t, double s, double ds, double &ref) const override
Definition: basicconstraintsandreferences.h:618
double constraintClearance_
Definition: basicconstraintsandreferences.h:609
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:630
LFVSpeedLimit lFVSpeedLimit_
Definition: basicconstraintsandreferences.h:606
CurvatureSpeedLimit curvatureSpeedLimit_
Definition: basicconstraintsandreferences.h:607
adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:608
void setSpeedScale(double value)
Definition: basicconstraintsandreferences.h:626
double speed_scale_
Definition: basicconstraintsandreferences.h:610
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:640
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:605
Definition: basicconstraintsandreferences.h:264
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:283
const adore::params::APTacticalPlanner * ptac_
Definition: basicconstraintsandreferences.h:270
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:312
adore::view::ALane * lfv_
Definition: basicconstraintsandreferences.h:266
const adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:267
const adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:269
StopAtBottleneckLFV(adore::view::ALane *lfv, const adore::params::APLongitudinalPlanner *plon, const adore::params::APVehicle *pv, const adore::params::APTrajectoryGeneration *pgen, const adore::params::APTacticalPlanner *ptac)
Definition: basicconstraintsandreferences.h:274
double distance_
Definition: basicconstraintsandreferences.h:271
const adore::params::APVehicle * pv_
Definition: basicconstraintsandreferences.h:268
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:304
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:308
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:287
double ds_sample_
Definition: basicconstraintsandreferences.h:272
Definition: basicconstraintsandreferences.h:1179
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:1221
const adore::view::AConflictPointSet * conflicts_
Definition: basicconstraintsandreferences.h:1181
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:1203
adore::params::APLongitudinalPlanner * plon_
Definition: basicconstraintsandreferences.h:1185
void setView(adore::view::AConflictPointSet *conflicts)
Definition: basicconstraintsandreferences.h:1188
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:1199
StopAtNextConflictPoint(const adore::view::AConflictPointSet *conflicts)
Definition: basicconstraintsandreferences.h:1192
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:1213
double distance_to_point_
Definition: basicconstraintsandreferences.h:1182
double smax_
Definition: basicconstraintsandreferences.h:1183
adore::params::APVehicle * pvehicle_
Definition: basicconstraintsandreferences.h:1184
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:1217
Definition: basicconstraintsandreferences.h:1133
const adore::params::APVehicle * pveh_
Definition: basicconstraintsandreferences.h:1136
virtual double getValue(double t, double s, double ds) const override
Definition: basicconstraintsandreferences.h:1146
virtual int getDimension() override
Definition: basicconstraintsandreferences.h:1165
const adore::view::ANavigationGoalView * next_
Definition: basicconstraintsandreferences.h:1135
StopAtNextGoalPoint(const adore::view::ANavigationGoalView *next)
Definition: basicconstraintsandreferences.h:1140
const adore::params::APTrajectoryGeneration * pgen_
Definition: basicconstraintsandreferences.h:1137
virtual ConstraintDirection getDirection() override
Definition: basicconstraintsandreferences.h:1161
virtual int getDerivative() override
Definition: basicconstraintsandreferences.h:1169
virtual void update(double t0, double s0, double ds0) override
Definition: basicconstraintsandreferences.h:1150
double s_max_
Definition: basicconstraintsandreferences.h:1138
virtual APLateralPlanner * getLateralPlanner() const =0
virtual APTacticalPlanner * getTacticalPlanner() const =0
virtual APTrajectoryGeneration * getTrajectoryGeneration() const =0
virtual APVehicle * getVehicle() const =0
virtual APLongitudinalPlanner * getLongitudinalPlanner() const =0
abstract class containing parameters related to configuring the lateral planner
Definition: ap_lateral_planner.h:26
virtual double getMinimumLateralControlSpace() const =0
getMinimumLateralControlSpace returns the minimum desired lateral control space: If vehicle has more ...
virtual double getRelativeHeadingUB() const =0
getRelativeHeadingUB returns upper bound on heading deviation from current lane's coordinate system
virtual double getAccLB() const =0
getAccLB returns lateral acceleration lower bound
virtual double getAccUB() const =0
getAccUB returns lateral acceleration upper bound
virtual double getLateralGridScale() const =0
getLateralGridScale returns the size of a grid step d for lateral variations of a maneuver: maneuver ...
virtual double getCurvatureUB() const =0
getCurvatureUB returns maximum curvature of path (relevant at low speeds)
virtual double getCurvatureLB() const =0
getCurvatureLB returns minimum curvature of path (relevant at low speeds)
virtual double getHardSafetyDistanceToLaneBoundary() const =0
getHardSafetyDistanceToLaneBoundary returns the minimum distance between lane boundary and vehicle si...
virtual double getMergeConstraintDelay() const =0
getMergeConstraintDelay returns a time-delay after which lateral position constraints are activated,...
virtual double getSoftSafetyDistanceToLaneBoundary() const =0
getSoftSafetyDistanceToLaneBoundary returns the minimum distance between lane boundary and vehicle si...
virtual double getRelativeHeadingLB() const =0
getRelativeHeadingLB returns lower bound on heading deviation from current lane's coordinate system
abstract class containing parameters related to configuring the longitudinal planner
Definition: ap_longitudinal_planner.h:26
virtual double getAccLatUB() const =0
getAccLatUB returns the absolute lateral acceleration bound which has to be maintained by reducing sp...
virtual double getVAccUBSlow() const =0
getVAccUBSlow returns speed up to which slow speed acceleration is used
virtual double getAccUBSlow() const =0
getAccUBSlow returns acceleration upper bound at low speeds
virtual double getAccLatUB_minVelocity() const =0
getAccLatUB_minVelocity returns the minimum velocity, which is always feasible despite getAccLatUB
virtual double getMinWidthFastSpeed() const =0
getMinWidthFastSpeed returns the fast speed to be applied, if lane width equals minWidthFast: Should ...
virtual double stopAtRedLights_max_connection_length() const =0
stopAtRedLights_max_connection_length returns the maximum length for which clearance based on tcd sta...
virtual bool stopAtRedLights_always_before() const =0
determin stop mode for red lights: true - always before red light, continue driving after; false - ba...
virtual double getMinWidthStop() const =0
getMinWidthStop returns the minimum lane width, below/at which vehicle stops: Should be greater or eq...
virtual double getConstraintClearanceVel() const =0
getConstraintClearanceVel returns the offset of the reference from the velocity constraints
virtual double getMinWidthSlow() const =0
getMinWidthSlow returns the minimum lane width, below/at which vehicle moves slowly: Should be greate...
virtual double getAccUB() const =0
getAccUB returns longitudinal acceleration upper bound
virtual double getStopDistanceToConflictPoint() const =0
distance between stop position and conflict point
virtual double getComfortAccLB() const =0
getAccLB returns longitudinal acceleration lower bound
virtual double getMinWidthFast() const =0
getMinWidthFast returns the minimum lane width, below/at which vehicle moves fast: Should be greater ...
virtual double getAccLB() const =0
getAccLB returns longitudinal acceleration lower bound
virtual double getMinWidthSlowSpeed() const =0
getMinWidthSlowSpeed returns the slow speed to be applied, if lane width equals minWidthSlow: Should ...
abstract classs containing parameters to configure aspects and constraints of the tactical planner
Definition: ap_tactical_planner.h:25
virtual double getGlobalSpeedLimit() const =0
virtual double getFrontSGap() const =0
virtual double getFrontTimeGap() const =0
virtual double getLowerBoundFrontSGapForLF() const =0
virtual double getHorizonStopReferenceDistance() const =0
virtual double getAssumedNominalAccelerationMinimum() const =0
abstract class containing parameters to configure the behaviour of trajectory generation
Definition: ap_trajectory_generation.h:26
virtual double get_rho() const =0
cor to planning point: movement of planning point shall planned by the trajectory planner
abstract class for vehicle configuration related paremeters
Definition: ap_vehicle.h:29
virtual double get_b() const =0
rear axle to cog
virtual double get_bodyWidth() const =0
virtual double get_d() const =0
rear border to rear axle
virtual double get_a() const =0
cog to front axle
virtual double get_c() const =0
front axle to front border
static adore::params::AFactory * get()
Definition: afactory.h:103
Definition: aconflictpoint.h:29
virtual int size() const =0
virtual ConflictPoint getPoint(int i) const =0
Definition: alane.h:28
virtual double getSpeedLimit(double s)=0
virtual const TrafficQueue & getOnLaneTraffic() const =0
virtual double getOffsetOfRightBorder(double s)=0
virtual double getSMax() const =0
virtual double getOffsetOfLeftBorder(double s)=0
virtual double getCurvature(double s, int derivative)=0
Definition: alimitlineenroute.h:26
virtual bool hasLimitLine(double s0)=0
virtual LimitLine getLimitLine(double t0, double s0)=0
Definition: anavigationgoalview.h:25
virtual const bool isNextGoalPointInView() const =0
virtual const double getProgress() const =0
virtual const bool isNextGoalPointFinal() const =0
T min(T a, T b, T c, T d)
Definition: adoremath.h:663
adoreMatrix< T, N, M > max(adoreMatrix< T, N, M > a, const adoreMatrix< T, N, M > &b)
Definition: adoremath.h:686
std::vector< TrafficObject > TrafficQueue
Definition: trafficobject.h:183
Definition: areaofeffectconverter.h:20
@ permissive_clearance
Definition: limitline.h:49
@ permissive_Movement_Allowed
Definition: limitline.h:47
@ caution_Conflicting_Traffic
Definition: limitline.h:51
@ dark
Definition: limitline.h:43
@ protected_clearance
Definition: limitline.h:50
@ protected_Movement_Allowed
Definition: limitline.h:48