#include <piecewise_jerk_problem.h>

类 apollo::planning::PiecewiseJerkProblem 继承关系图:

apollo::planning::PiecewiseJerkProblem 的协作图:

Public 成员函数
	PiecewiseJerkProblem (const size_t num_of_knots, const double delta_s, const std::array< double, 3 > &x_init)

virtual	~PiecewiseJerkProblem ()=default

void	set_x_bounds (std::vector< std::pair< double, double > > x_bounds)

void	set_x_bounds (const double x_lower_bound, const double x_upper_bound)

void	set_dx_bounds (std::vector< std::pair< double, double > > dx_bounds)

void	set_dx_bounds (const double dx_lower_bound, const double dx_upper_bound)

void	set_ddx_bounds (std::vector< std::pair< double, double > > ddx_bounds)

void	set_ddx_bounds (const double ddx_lower_bound, const double ddx_upper_bound)

void	set_dddx_bound (const double dddx_bound)

void	set_dddx_bound (const double dddx_lower_bound, const double dddx_upper_bound)

void	set_weight_x (const double weight_x)

void	set_weight_dx (const double weight_dx)

void	set_weight_ddx (const double weight_ddx)

void	set_weight_dddx (const double weight_dddx)

void	set_scale_factor (const std::array< double, 3 > &scale_factor)

void	set_x_ref (const double weight_x_ref, std::vector< double > x_ref)
	Set the x ref object and the uniform x_ref weighting

void	set_x_ref (std::vector< double > weight_x_ref_vec, std::vector< double > x_ref)
	Set the x ref object and piecewised x_ref weightings

void	set_towing_x_ref (const double weight_towing_x_ref, std::vector< double > towing_x_ref)
	Set towing x ref object and piecewised towing_x_ref weightings

void	set_towing_x_ref (std::vector< double > weight_towing_x_ref_vec, std::vector< double > towing_x_ref)

void	set_end_state_ref (const std::array< double, 3 > &weight_end_state, const std::array< double, 3 > &end_state_ref)

virtual bool	Optimize (const int max_iter=4000)

const std::vector< double > &	opt_x () const

const std::vector< double > &	opt_dx () const

const std::vector< double > &	opt_ddx () const

Protected 成员函数
virtual void	CalculateKernel (std::vector< c_float > P_data, std::vector< c_int > P_indices, std::vector< c_int > *P_indptr)=0

virtual void	CalculateOffset (std::vector< c_float > *q)=0

virtual void	CalculateAffineConstraint (std::vector< c_float > A_data, std::vector< c_int > A_indices, std::vector< c_int > A_indptr, std::vector< c_float > lower_bounds, std::vector< c_float > *upper_bounds)

virtual OSQPSettings *	SolverDefaultSettings ()

bool	FormulateProblem (OSQPData *data)

void	FreeData (OSQPData *data)

bool	CheckLowUpperBound (const std::vector< c_float > &lower, const std::vector< c_float > &upper)

template<typename T >
T *	CopyData (const std::vector< T > &vec)

Protected 属性
size_t	num_of_knots_ = 0

std::vector< double >	x_

std::vector< double >	dx_

std::vector< double >	ddx_

std::array< double, 3 >	x_init_

std::array< double, 3 >	scale_factor_ = {{1.0, 1.0, 1.0}}

std::vector< std::pair< double, double > >	x_bounds_

std::vector< std::pair< double, double > >	dx_bounds_

std::vector< std::pair< double, double > >	ddx_bounds_

std::pair< double, double >	dddx_bound_

double	weight_x_ = 0.0

double	weight_dx_ = 0.0

double	weight_ddx_ = 0.0

double	weight_dddx_ = 0.0

double	delta_s_ = 1.0

bool	has_x_ref_ = false

double	weight_x_ref_ = 0.0

std::vector< double >	x_ref_

std::vector< double >	weight_x_ref_vec_

bool	has_towing_x_ref_ = false

std::vector< double >	towing_x_ref_

std::vector< double >	weight_towing_x_ref_vec_

bool	has_end_state_ref_ = false

std::array< double, 3 >	weight_end_state_ = {{0.0, 0.0, 0.0}}

std::array< double, 3 >	end_state_ref_

详细描述

在文件 piecewise_jerk_problem.h 第 49 行定义.

构造及析构函数说明

◆ PiecewiseJerkProblem()

apollo::planning::PiecewiseJerkProblem::PiecewiseJerkProblem	(	const size_t	num_of_knots,
		const double	delta_s,
		const std::array< double, 3 > &	x_init
	)

在文件 piecewise_jerk_problem.cc 第 29 行定义.

                                       {
  CHECK_GE(num_of_knots, 2U);
  num_of_knots_ = num_of_knots;
 
  x_init_ = x_init;
 
  delta_s_ = delta_s;
 
  x_bounds_.resize(num_of_knots_,
                   std::make_pair(-kMaxVariableRange, kMaxVariableRange));
 
  dx_bounds_.resize(num_of_knots_,
                    std::make_pair(-kMaxVariableRange, kMaxVariableRange));
 
  ddx_bounds_.resize(num_of_knots_,
                     std::make_pair(-kMaxVariableRange, kMaxVariableRange));
 
  weight_x_ref_vec_ = std::vector<double>(num_of_knots_, 0.0);
}

◆ ~PiecewiseJerkProblem()

virtual apollo::planning::PiecewiseJerkProblem::~PiecewiseJerkProblem ( )

virtualdefault

成员函数说明

◆ CalculateAffineConstraint()

void apollo::planning::PiecewiseJerkProblem::CalculateAffineConstraint	(	std::vector< c_float > *	A_data,
		std::vector< c_int > *	A_indices,
		std::vector< c_int > *	A_indptr,
		std::vector< c_float > *	lower_bounds,
		std::vector< c_float > *	upper_bounds
	)

protectedvirtual

被 apollo::planning::PiecewiseJerkPathProblem 重载.

在文件 piecewise_jerk_problem.cc 第 136 行定义.

                                      {
  // 3N params bounds on x, x', x''
  // 3(N-1) constraints on x, x', x''
  // 3 constraints on x_init_
  const int n = static_cast<int>(num_of_knots_);
  const int num_of_variables = 3 * n;
  const int num_of_constraints = num_of_variables + 3 * (n - 1) + 3;
  lower_bounds->resize(num_of_constraints);
  upper_bounds->resize(num_of_constraints);
 
  std::vector<std::vector<std::pair<c_int, c_float>>> variables(
      num_of_variables);
 
  int constraint_index = 0;
  // set x, x', x'' bounds
  for (int i = 0; i < num_of_variables; ++i) {
    if (i < n) {
      variables[i].emplace_back(constraint_index, 1.0);
      lower_bounds->at(constraint_index) =
          x_bounds_[i].first * scale_factor_[0];
      upper_bounds->at(constraint_index) =
          x_bounds_[i].second * scale_factor_[0];
    } else if (i < 2 * n) {
      variables[i].emplace_back(constraint_index, 1.0);
 
      lower_bounds->at(constraint_index) =
          dx_bounds_[i - n].first * scale_factor_[1];
      upper_bounds->at(constraint_index) =
          dx_bounds_[i - n].second * scale_factor_[1];
    } else {
      variables[i].emplace_back(constraint_index, 1.0);
      lower_bounds->at(constraint_index) =
          ddx_bounds_[i - 2 * n].first * scale_factor_[2];
      upper_bounds->at(constraint_index) =
          ddx_bounds_[i - 2 * n].second * scale_factor_[2];
    }
    ++constraint_index;
  }
  CHECK_EQ(constraint_index, num_of_variables);
 
  // x(i->i+1)''' = (x(i+1)'' - x(i)'') / delta_s
  for (int i = 0; i + 1 < n; ++i) {
    variables[2 * n + i].emplace_back(constraint_index, -1.0);
    variables[2 * n + i + 1].emplace_back(constraint_index, 1.0);
    lower_bounds->at(constraint_index) =
        dddx_bound_.first * delta_s_ * scale_factor_[2];
    upper_bounds->at(constraint_index) =
        dddx_bound_.second * delta_s_ * scale_factor_[2];
    ++constraint_index;
  }
 
  // x(i+1)' - x(i)' - 0.5 * delta_s * x(i)'' - 0.5 * delta_s * x(i+1)'' = 0
  for (int i = 0; i + 1 < n; ++i) {
    variables[n + i].emplace_back(constraint_index, -1.0 * scale_factor_[2]);
    variables[n + i + 1].emplace_back(constraint_index, 1.0 * scale_factor_[2]);
    variables[2 * n + i].emplace_back(constraint_index,
                                      -0.5 * delta_s_ * scale_factor_[1]);
    variables[2 * n + i + 1].emplace_back(constraint_index,
                                          -0.5 * delta_s_ * scale_factor_[1]);
    lower_bounds->at(constraint_index) = 0.0;
    upper_bounds->at(constraint_index) = 0.0;
    ++constraint_index;
  }
 
  // x(i+1) - x(i) - delta_s * x(i)'
  // - 1/3 * delta_s^2 * x(i)'' - 1/6 * delta_s^2 * x(i+1)''
  auto delta_s_sq_ = delta_s_ * delta_s_;
  for (int i = 0; i + 1 < n; ++i) {
    variables[i].emplace_back(constraint_index,
                              -1.0 * scale_factor_[1] * scale_factor_[2]);
    variables[i + 1].emplace_back(constraint_index,
                                  1.0 * scale_factor_[1] * scale_factor_[2]);
    variables[n + i].emplace_back(
        constraint_index, -delta_s_ * scale_factor_[0] * scale_factor_[2]);
    variables[2 * n + i].emplace_back(
        constraint_index,
        -delta_s_sq_ / 3.0 * scale_factor_[0] * scale_factor_[1]);
    variables[2 * n + i + 1].emplace_back(
        constraint_index,
        -delta_s_sq_ / 6.0 * scale_factor_[0] * scale_factor_[1]);
 
    lower_bounds->at(constraint_index) = 0.0;
    upper_bounds->at(constraint_index) = 0.0;
    ++constraint_index;
  }
 
  // constrain on x_init
  variables[0].emplace_back(constraint_index, 1.0);
  lower_bounds->at(constraint_index) = x_init_[0] * scale_factor_[0];
  upper_bounds->at(constraint_index) = x_init_[0] * scale_factor_[0];
  ++constraint_index;
 
  variables[n].emplace_back(constraint_index, 1.0);
  lower_bounds->at(constraint_index) = x_init_[1] * scale_factor_[1];
  upper_bounds->at(constraint_index) = x_init_[1] * scale_factor_[1];
  ++constraint_index;
 
  variables[2 * n].emplace_back(constraint_index, 1.0);
  lower_bounds->at(constraint_index) = x_init_[2] * scale_factor_[2];
  upper_bounds->at(constraint_index) = x_init_[2] * scale_factor_[2];
  ++constraint_index;
 
  CHECK_EQ(constraint_index, num_of_constraints);
 
  int ind_p = 0;
  for (int i = 0; i < num_of_variables; ++i) {
    A_indptr->push_back(ind_p);
    for (const auto& variable_nz : variables[i]) {
      // coefficient
      A_data->push_back(variable_nz.second);
 
      // constraint index
      A_indices->push_back(variable_nz.first);
      ++ind_p;
    }
  }
  // We indeed need this line because of
  // https://github.com/oxfordcontrol/osqp/blob/master/src/cs.c#L255
  A_indptr->push_back(ind_p);
}

◆ CalculateKernel()

virtual void apollo::planning::PiecewiseJerkProblem::CalculateKernel	(	std::vector< c_float > *	P_data,
		std::vector< c_int > *	P_indices,
		std::vector< c_int > *	P_indptr
	)

protectedpure virtual

在 apollo::planning::PiecewiseJerkPathProblem , 以及 apollo::planning::PiecewiseJerkSpeedProblem 内被实现.

◆ CalculateOffset()

virtual void apollo::planning::PiecewiseJerkProblem::CalculateOffset ( std::vector< c_float > * q )

protectedpure virtual

在 apollo::planning::PiecewiseJerkPathProblem , 以及 apollo::planning::PiecewiseJerkSpeedProblem 内被实现.

◆ CheckLowUpperBound()

bool apollo::planning::PiecewiseJerkProblem::CheckLowUpperBound	(	const std::vector< c_float > &	lower,
		const std::vector< c_float > &	upper
	)

protected

在文件 piecewise_jerk_problem.cc 第 374 行定义.

                                                                      {
  for (size_t i = 0; i < lower.size(); i++) {
    if (lower[i] > upper[i]) {
      return true;
    }
  }
  return false;
}

◆ CopyData()

template<typename T >

T * apollo::planning::PiecewiseJerkProblem::CopyData ( const std::vector< T > & vec )

inlineprotected

在文件 piecewise_jerk_problem.h 第 155 行定义.

                                       {
    T* data = new T[vec.size()];
    memcpy(data, vec.data(), sizeof(T) * vec.size());
    return data;
  }

◆ FormulateProblem()

bool apollo::planning::PiecewiseJerkProblem::FormulateProblem ( OSQPData * data )

protected

在文件 piecewise_jerk_problem.cc 第 51 行定义.

                                                          {
  // calculate kernel
  std::vector<c_float> P_data;
  std::vector<c_int> P_indices;
  std::vector<c_int> P_indptr;
  CalculateKernel(&P_data, &P_indices, &P_indptr);
 
  // calculate affine constraints
  std::vector<c_float> A_data;
  std::vector<c_int> A_indices;
  std::vector<c_int> A_indptr;
  std::vector<c_float> lower_bounds;
  std::vector<c_float> upper_bounds;
  CalculateAffineConstraint(&A_data, &A_indices, &A_indptr, &lower_bounds,
                            &upper_bounds);
 
  // calculate offset
  std::vector<c_float> q;
  CalculateOffset(&q);
 
  CHECK_EQ(lower_bounds.size(), upper_bounds.size());
 
  size_t kernel_dim = 3 * num_of_knots_;
  size_t num_affine_constraint = lower_bounds.size();
 
  data->n = kernel_dim;
  data->m = num_affine_constraint;
  data->P = csc_matrix(kernel_dim, kernel_dim, P_data.size(), CopyData(P_data),
                       CopyData(P_indices), CopyData(P_indptr));
  data->q = CopyData(q);
  data->A =
      csc_matrix(num_affine_constraint, kernel_dim, A_data.size(),
                 CopyData(A_data), CopyData(A_indices), CopyData(A_indptr));
  data->l = CopyData(lower_bounds);
  data->u = CopyData(upper_bounds);
 
  return CheckLowUpperBound(lower_bounds, upper_bounds);
}

◆ FreeData()

void apollo::planning::PiecewiseJerkProblem::FreeData ( OSQPData * data )

protected

在文件 piecewise_jerk_problem.cc 第 360 行定义.

                                                  {
  delete[] data->q;
  delete[] data->l;
  delete[] data->u;
 
  delete[] data->P->i;
  delete[] data->P->p;
  delete[] data->P->x;
 
  delete[] data->A->i;
  delete[] data->A->p;
  delete[] data->A->x;
}

◆ opt_ddx()

const std::vector< double > & apollo::planning::PiecewiseJerkProblem::opt_ddx ( ) const

inline

在文件 piecewise_jerk_problem.h 第 129 行定义.

129{ return ddx_; }

apollo::planning::PiecewiseJerkProblem::ddx_

std::vector< double > ddx_

Definition piecewise_jerk_problem.h:167

◆ opt_dx()

const std::vector< double > & apollo::planning::PiecewiseJerkProblem::opt_dx ( ) const

inline

在文件 piecewise_jerk_problem.h 第 127 行定义.

127{ return dx_; }

apollo::planning::PiecewiseJerkProblem::dx_

std::vector< double > dx_

Definition piecewise_jerk_problem.h:166

◆ opt_x()

const std::vector< double > & apollo::planning::PiecewiseJerkProblem::opt_x ( ) const

inline

在文件 piecewise_jerk_problem.h 第 125 行定义.

125{ return x_; }

apollo::planning::PiecewiseJerkProblem::x_

std::vector< double > x_

Definition piecewise_jerk_problem.h:165

◆ Optimize()

bool apollo::planning::PiecewiseJerkProblem::Optimize ( const int max_iter = 4000 )

virtual

在文件 piecewise_jerk_problem.cc 第 90 行定义.

                                                      {
  OSQPData* data = reinterpret_cast<OSQPData*>(c_malloc(sizeof(OSQPData)));
  if (FormulateProblem(data)) {
    FreeData(data);
    return false;
  }
  OSQPSettings* settings = SolverDefaultSettings();
  settings->max_iter = max_iter;
  OSQPWorkspace* osqp_work = nullptr;
  osqp_work = osqp_setup(data, settings);
  // osqp_setup(&osqp_work, data, settings);
  osqp_solve(osqp_work);
  auto status = osqp_work->info->status_val;
 
  if (status < 0 || (status != 1 && status != 2)) {
    AERROR << "failed optimization status:\t" << osqp_work->info->status;
    osqp_cleanup(osqp_work);
    FreeData(data);
    c_free(settings);
    return false;
  } else if (osqp_work->solution == nullptr) {
    AERROR << "The solution from OSQP is nullptr";
    osqp_cleanup(osqp_work);
    FreeData(data);
    c_free(settings);
    return false;
  }
 
  // extract primal results
  x_.resize(num_of_knots_);
  dx_.resize(num_of_knots_);
  ddx_.resize(num_of_knots_);
  for (size_t i = 0; i < num_of_knots_; ++i) {
    x_.at(i) = osqp_work->solution->x[i] / scale_factor_[0];
    dx_.at(i) = osqp_work->solution->x[i + num_of_knots_] / scale_factor_[1];
    ddx_.at(i) =
        osqp_work->solution->x[i + 2 * num_of_knots_] / scale_factor_[2];
  }
 
  // Cleanup
  osqp_cleanup(osqp_work);
  FreeData(data);
  c_free(settings);
  return true;
}

◆ set_dddx_bound() [1/2]

void apollo::planning::PiecewiseJerkProblem::set_dddx_bound ( const double dddx_bound )

inline

在文件 piecewise_jerk_problem.h 第 69 行定义.

                                               {
    set_dddx_bound(-dddx_bound, dddx_bound);
  }

◆ set_dddx_bound() [2/2]

void apollo::planning::PiecewiseJerkProblem::set_dddx_bound	(	const double	dddx_lower_bound,
		const double	dddx_upper_bound
	)

inline

在文件 piecewise_jerk_problem.h 第 73 行定义.

                                                     {
    dddx_bound_.first = dddx_lower_bound;
    dddx_bound_.second = dddx_upper_bound;
  }

◆ set_ddx_bounds() [1/2]

void apollo::planning::PiecewiseJerkProblem::set_ddx_bounds	(	const double	ddx_lower_bound,
		const double	ddx_upper_bound
	)

在文件 piecewise_jerk_problem.cc 第 305 行定义.

                                                                        {
  for (auto& x : ddx_bounds_) {
    x.first = ddx_lower_bound;
    x.second = ddx_upper_bound;
  }
}

◆ set_ddx_bounds() [2/2]

void apollo::planning::PiecewiseJerkProblem::set_ddx_bounds ( std::vector< std::pair< double, double > > ddx_bounds )

在文件 piecewise_jerk_problem.cc 第 283 行定义.

                                                   {
  CHECK_EQ(ddx_bounds.size(), num_of_knots_);
  ddx_bounds_ = std::move(ddx_bounds);
}

◆ set_dx_bounds() [1/2]

void apollo::planning::PiecewiseJerkProblem::set_dx_bounds	(	const double	dx_lower_bound,
		const double	dx_upper_bound
	)

在文件 piecewise_jerk_problem.cc 第 297 行定义.

                                                                      {
  for (auto& x : dx_bounds_) {
    x.first = dx_lower_bound;
    x.second = dx_upper_bound;
  }
}

◆ set_dx_bounds() [2/2]

void apollo::planning::PiecewiseJerkProblem::set_dx_bounds ( std::vector< std::pair< double, double > > dx_bounds )

在文件 piecewise_jerk_problem.cc 第 277 行定义.

                                                  {
  CHECK_EQ(dx_bounds.size(), num_of_knots_);
  dx_bounds_ = std::move(dx_bounds);
}

◆ set_end_state_ref()

void apollo::planning::PiecewiseJerkProblem::set_end_state_ref	(	const std::array< double, 3 > &	weight_end_state,
		const std::array< double, 3 > &	end_state_ref
	)

在文件 piecewise_jerk_problem.cc 第 352 行定义.

                                              {
  weight_end_state_ = weight_end_state;
  end_state_ref_ = end_state_ref;
  has_end_state_ref_ = true;
}

◆ set_scale_factor()

void apollo::planning::PiecewiseJerkProblem::set_scale_factor ( const std::array< double, 3 > & scale_factor )

inline

在文件 piecewise_jerk_problem.h 第 87 行定义.

                                                                 {
    scale_factor_ = scale_factor;
  }

◆ set_towing_x_ref() [1/2]

void apollo::planning::PiecewiseJerkProblem::set_towing_x_ref	(	const double	weight_towing_x_ref,
		std::vector< double >	towing_x_ref
	)

Set towing x ref object and piecewised towing_x_ref weightings

参数

weight_towing_x_ref_vec	piecewised towing x_ref weightings
towing_x_ref	objective value of x

在文件 piecewise_jerk_problem.cc 第 333 行定义.

                                                                            {
  CHECK_EQ(towing_x_ref.size(), num_of_knots_);
  weight_towing_x_ref_vec_ =
      std::vector<double>(num_of_knots_, weight_towing_x_ref);
  towing_x_ref_ = std::move(towing_x_ref);
  has_towing_x_ref_ = true;
}

◆ set_towing_x_ref() [2/2]

void apollo::planning::PiecewiseJerkProblem::set_towing_x_ref	(	std::vector< double >	weight_towing_x_ref_vec,
		std::vector< double >	towing_x_ref
	)

在文件 piecewise_jerk_problem.cc 第 342 行定义.

                                    {
  CHECK_EQ(towing_x_ref.size(), num_of_knots_);
  CHECK_EQ(weight_towing_x_ref_vec.size(), num_of_knots_);
  weight_towing_x_ref_vec_ = std::move(weight_towing_x_ref_vec);
  towing_x_ref_ = std::move(towing_x_ref);
  has_towing_x_ref_ = true;
}

◆ set_weight_dddx()

void apollo::planning::PiecewiseJerkProblem::set_weight_dddx ( const double weight_dddx )

inline

在文件 piecewise_jerk_problem.h 第 85 行定义.

85{ weight_dddx_ = weight_dddx; }

apollo::planning::PiecewiseJerkProblem::weight_dddx_

double weight_dddx_

Definition piecewise_jerk_problem.h:180

◆ set_weight_ddx()

void apollo::planning::PiecewiseJerkProblem::set_weight_ddx ( const double weight_ddx )

inline

在文件 piecewise_jerk_problem.h 第 83 行定义.

83{ weight_ddx_ = weight_ddx; }

apollo::planning::PiecewiseJerkProblem::weight_ddx_

double weight_ddx_

Definition piecewise_jerk_problem.h:179

◆ set_weight_dx()

void apollo::planning::PiecewiseJerkProblem::set_weight_dx ( const double weight_dx )

inline

在文件 piecewise_jerk_problem.h 第 81 行定义.

81{ weight_dx_ = weight_dx; }

apollo::planning::PiecewiseJerkProblem::weight_dx_

double weight_dx_

Definition piecewise_jerk_problem.h:178

◆ set_weight_x()

void apollo::planning::PiecewiseJerkProblem::set_weight_x ( const double weight_x )

inline

在文件 piecewise_jerk_problem.h 第 79 行定义.

79{ weight_x_ = weight_x; }

apollo::planning::PiecewiseJerkProblem::weight_x_

double weight_x_

Definition piecewise_jerk_problem.h:177

◆ set_x_bounds() [1/2]

void apollo::planning::PiecewiseJerkProblem::set_x_bounds	(	const double	x_lower_bound,
		const double	x_upper_bound
	)

在文件 piecewise_jerk_problem.cc 第 289 行定义.

                                                                    {
  for (auto& x : x_bounds_) {
    x.first = x_lower_bound;
    x.second = x_upper_bound;
  }
}

◆ set_x_bounds() [2/2]

void apollo::planning::PiecewiseJerkProblem::set_x_bounds ( std::vector< std::pair< double, double > > x_bounds )

在文件 piecewise_jerk_problem.cc 第 271 行定义.

                                                 {
  CHECK_EQ(x_bounds.size(), num_of_knots_);
  x_bounds_ = std::move(x_bounds);
}

◆ set_x_ref() [1/2]

void apollo::planning::PiecewiseJerkProblem::set_x_ref	(	const double	weight_x_ref,
		std::vector< double >	x_ref
	)

Set the x ref object and the uniform x_ref weighting

参数

weight_x_ref	uniform weighting for x_ref
x_ref	objective value of x

在文件 piecewise_jerk_problem.cc 第 313 行定义.

                                                              {
  CHECK_EQ(x_ref.size(), num_of_knots_);
  weight_x_ref_ = weight_x_ref;
  // set uniform weighting
  weight_x_ref_vec_ = std::vector<double>(num_of_knots_, weight_x_ref);
  x_ref_ = std::move(x_ref);
  has_x_ref_ = true;
}

◆ set_x_ref() [2/2]

void apollo::planning::PiecewiseJerkProblem::set_x_ref	(	std::vector< double >	weight_x_ref_vec,
		std::vector< double >	x_ref
	)

Set the x ref object and piecewised x_ref weightings

参数

weight_x_ref_vec	piecewised x_ref weightings
x_ref	objective value of x

在文件 piecewise_jerk_problem.cc 第 323 行定义.

                                                              {
  CHECK_EQ(x_ref.size(), num_of_knots_);
  CHECK_EQ(weight_x_ref_vec.size(), num_of_knots_);
  // set piecewise weighting
  weight_x_ref_vec_ = std::move(weight_x_ref_vec);
  x_ref_ = std::move(x_ref);
  has_x_ref_ = true;
}

◆ SolverDefaultSettings()

OSQPSettings * apollo::planning::PiecewiseJerkProblem::SolverDefaultSettings ( )

protectedvirtual

被 apollo::planning::PiecewiseJerkPathProblem , 以及 apollo::planning::PiecewiseJerkSpeedProblem 重载.

在文件 piecewise_jerk_problem.cc 第 260 行定义.

                                                          {
  // Define Solver default settings
  OSQPSettings* settings =
      reinterpret_cast<OSQPSettings*>(c_malloc(sizeof(OSQPSettings)));
  osqp_set_default_settings(settings);
  settings->polish = true;
  settings->verbose = FLAGS_enable_osqp_debug;
  settings->scaled_termination = true;
  return settings;
}

类成员变量说明

◆ dddx_bound_

std::pair<double, double> apollo::planning::PiecewiseJerkProblem::dddx_bound_

protected

在文件 piecewise_jerk_problem.h 第 175 行定义.

◆ ddx_

std::vector<double> apollo::planning::PiecewiseJerkProblem::ddx_

protected

在文件 piecewise_jerk_problem.h 第 167 行定义.

◆ ddx_bounds_

std::vector<std::pair<double, double> > apollo::planning::PiecewiseJerkProblem::ddx_bounds_

protected

在文件 piecewise_jerk_problem.h 第 174 行定义.

◆ delta_s_

double apollo::planning::PiecewiseJerkProblem::delta_s_ = 1.0

protected

在文件 piecewise_jerk_problem.h 第 182 行定义.

◆ dx_

std::vector<double> apollo::planning::PiecewiseJerkProblem::dx_

protected

在文件 piecewise_jerk_problem.h 第 166 行定义.

◆ dx_bounds_

std::vector<std::pair<double, double> > apollo::planning::PiecewiseJerkProblem::dx_bounds_

protected

在文件 piecewise_jerk_problem.h 第 173 行定义.

◆ end_state_ref_

std::array<double, 3> apollo::planning::PiecewiseJerkProblem::end_state_ref_

protected

在文件 piecewise_jerk_problem.h 第 196 行定义.

◆ has_end_state_ref_

bool apollo::planning::PiecewiseJerkProblem::has_end_state_ref_ = false

protected

在文件 piecewise_jerk_problem.h 第 194 行定义.

◆ has_towing_x_ref_

bool apollo::planning::PiecewiseJerkProblem::has_towing_x_ref_ = false

protected

在文件 piecewise_jerk_problem.h 第 190 行定义.

◆ has_x_ref_

bool apollo::planning::PiecewiseJerkProblem::has_x_ref_ = false

protected

在文件 piecewise_jerk_problem.h 第 184 行定义.

◆ num_of_knots_

size_t apollo::planning::PiecewiseJerkProblem::num_of_knots_ = 0

protected

在文件 piecewise_jerk_problem.h 第 162 行定义.

◆ scale_factor_

std::array<double, 3> apollo::planning::PiecewiseJerkProblem::scale_factor_ = {{1.0, 1.0, 1.0}}

protected

在文件 piecewise_jerk_problem.h 第 170 行定义.

170{{1.0, 1.0, 1.0}};

◆ towing_x_ref_

std::vector<double> apollo::planning::PiecewiseJerkProblem::towing_x_ref_

protected

在文件 piecewise_jerk_problem.h 第 191 行定义.

◆ weight_dddx_

double apollo::planning::PiecewiseJerkProblem::weight_dddx_ = 0.0

protected

在文件 piecewise_jerk_problem.h 第 180 行定义.

◆ weight_ddx_

double apollo::planning::PiecewiseJerkProblem::weight_ddx_ = 0.0

protected

在文件 piecewise_jerk_problem.h 第 179 行定义.

◆ weight_dx_

double apollo::planning::PiecewiseJerkProblem::weight_dx_ = 0.0

protected

在文件 piecewise_jerk_problem.h 第 178 行定义.

◆ weight_end_state_

std::array<double, 3> apollo::planning::PiecewiseJerkProblem::weight_end_state_ = {{0.0, 0.0, 0.0}}

protected

在文件 piecewise_jerk_problem.h 第 195 行定义.

195{{0.0, 0.0, 0.0}};

◆ weight_towing_x_ref_vec_

std::vector<double> apollo::planning::PiecewiseJerkProblem::weight_towing_x_ref_vec_

protected

在文件 piecewise_jerk_problem.h 第 192 行定义.

◆ weight_x_

double apollo::planning::PiecewiseJerkProblem::weight_x_ = 0.0

protected

在文件 piecewise_jerk_problem.h 第 177 行定义.

◆ weight_x_ref_

double apollo::planning::PiecewiseJerkProblem::weight_x_ref_ = 0.0

protected

在文件 piecewise_jerk_problem.h 第 185 行定义.

◆ weight_x_ref_vec_

std::vector<double> apollo::planning::PiecewiseJerkProblem::weight_x_ref_vec_

protected

在文件 piecewise_jerk_problem.h 第 188 行定义.

◆ x_

std::vector<double> apollo::planning::PiecewiseJerkProblem::x_

protected

在文件 piecewise_jerk_problem.h 第 165 行定义.

◆ x_bounds_

std::vector<std::pair<double, double> > apollo::planning::PiecewiseJerkProblem::x_bounds_

protected

在文件 piecewise_jerk_problem.h 第 172 行定义.

◆ x_init_

std::array<double, 3> apollo::planning::PiecewiseJerkProblem::x_init_

protected

在文件 piecewise_jerk_problem.h 第 169 行定义.

◆ x_ref_

std::vector<double> apollo::planning::PiecewiseJerkProblem::x_ref_

protected

在文件 piecewise_jerk_problem.h 第 186 行定义.

该类的文档由以下文件生成:

modules/planning/planning_base/math/piecewise_jerk/piecewise_jerk_problem.h
modules/planning/planning_base/math/piecewise_jerk/piecewise_jerk_problem.cc

Public 成员函数

Protected 成员函数

Protected 属性

详细描述

构造及析构函数说明

◆ PiecewiseJerkProblem()

◆ ~PiecewiseJerkProblem()

成员函数说明

◆ CalculateAffineConstraint()

◆ CalculateKernel()

◆ CalculateOffset()

◆ CheckLowUpperBound()

◆ CopyData()

◆ FormulateProblem()

◆ FreeData()

◆ opt_ddx()

◆ opt_dx()

◆ opt_x()

◆ Optimize()

◆ set_dddx_bound() [1/2]

◆ set_dddx_bound() [2/2]

◆ set_ddx_bounds() [1/2]

◆ set_ddx_bounds() [2/2]

◆ set_dx_bounds() [1/2]

◆ set_dx_bounds() [2/2]

◆ set_end_state_ref()

◆ set_scale_factor()

◆ set_towing_x_ref() [1/2]

◆ set_towing_x_ref() [2/2]

◆ set_weight_dddx()

◆ set_weight_ddx()

◆ set_weight_dx()

◆ set_weight_x()

◆ set_x_bounds() [1/2]

◆ set_x_bounds() [2/2]

◆ set_x_ref() [1/2]

◆ set_x_ref() [2/2]

◆ SolverDefaultSettings()

类成员变量说明

◆ dddx_bound_

◆ ddx_

◆ ddx_bounds_

◆ delta_s_

◆ dx_

◆ dx_bounds_

◆ end_state_ref_

◆ has_end_state_ref_

◆ has_towing_x_ref_

◆ has_x_ref_

◆ num_of_knots_

◆ scale_factor_

◆ towing_x_ref_

◆ weight_dddx_

◆ weight_ddx_

◆ weight_dx_

◆ weight_end_state_

◆ weight_towing_x_ref_vec_

◆ weight_x_

◆ weight_x_ref_

◆ weight_x_ref_vec_

◆ x_

◆ x_bounds_

◆ x_init_

◆ x_ref_