Apollo 11.0
自动驾驶开放平台
Public 成员函数 | 所有成员列表
apollo::planning::Spline2dConstraint类 参考

#include <spline_2d_constraint.h>

apollo::planning::Spline2dConstraint 的协作图:

Public 成员函数

 Spline2dConstraint (const std::vector< double > &t_knots, const uint32_t order)
 
bool AddInequalityConstraint (const Eigen::MatrixXd &constraint_matrix, const Eigen::MatrixXd &constraint_boundary)
 
bool AddEqualityConstraint (const Eigen::MatrixXd &constraint_matrix, const Eigen::MatrixXd &constraint_boundary)
 
bool Add2dBoundary (const std::vector< double > &t_coord, const std::vector< double > &angle, const std::vector< apollo::common::math::Vec2d > &ref_point, const std::vector< double > &longitudinal_bound, const std::vector< double > &lateral_bound)
 : inequality boundary constraints if no boundary, do specify either by std::infinity or let vector.size() = 0
 
bool Add2dDerivativeBoundary (const std::vector< double > &t_coord, const std::vector< double > &angle, const std::vector< apollo::common::math::Vec2d > &ref_point, const std::vector< double > &longitudinal_bound, const std::vector< double > &lateral_bound)
 
bool Add2dSecondDerivativeBoundary (const std::vector< double > &t_coord, const std::vector< double > &angle, const std::vector< apollo::common::math::Vec2d > &ref_point, const std::vector< double > &longitudinal_bound, const std::vector< double > &lateral_bound)
 
bool Add2dThirdDerivativeBoundary (const std::vector< double > &t_coord, const std::vector< double > &angle, const std::vector< apollo::common::math::Vec2d > &ref_point, const std::vector< double > &longitudinal_bound, const std::vector< double > &lateral_bound)
 
bool AddPointConstraint (const double t, const double x, const double y)
 
bool AddPointSecondDerivativeConstraint (const double t, const double ddx, const double ddy)
 
bool AddPointThirdDerivativeConstraint (const double t, const double dddx, const double dddy)
 
bool AddPointAngleConstraint (const double t, const double angle)
 
bool AddSmoothConstraint ()
 
bool AddDerivativeSmoothConstraint ()
 
bool AddSecondDerivativeSmoothConstraint ()
 
bool AddThirdDerivativeSmoothConstraint ()
 
const AffineConstraint & inequality_constraint () const
 : output interface inequality constraint
 
const AffineConstraint & equality_constraint () const
 

详细描述

在文件 spline_2d_constraint.h 第 34 行定义.

构造及析构函数说明

◆ Spline2dConstraint()

apollo::planning::Spline2dConstraint::Spline2dConstraint ( const std::vector< double > &  t_knots,
const uint32_t  order 
)

在文件 spline_2d_constraint.cc 第 34 行定义.

36 : t_knots_(t_knots), spline_order_(order) {
37 inequality_constraint_.SetIsEquality(false);
38 equality_constraint_.SetIsEquality(true);
39 total_param_ =
40 2 * (spline_order_ + 1) * (static_cast<uint32_t>(t_knots.size()) - 1);
41}
apollo::planning::AffineConstraint::SetIsEquality
void SetIsEquality(const double is_equality)
Definition affine_constraint.cc:40

成员函数说明

◆ Add2dBoundary()

bool apollo::planning::Spline2dConstraint::Add2dBoundary ( const std::vector< double > &  t_coord,
const std::vector< double > &  angle,
const std::vector< apollo::common::math::Vec2d > &  ref_point,
const std::vector< double > &  longitudinal_bound,
const std::vector< double > &  lateral_bound 
)

: inequality boundary constraints if no boundary, do specify either by std::infinity or let vector.size() = 0

在文件 spline_2d_constraint.cc 第 63 行定义.

67 {
68 if (t_coord.size() != angle.size() || angle.size() != ref_point.size() ||
69 ref_point.size() != lateral_bound.size() ||
70 lateral_bound.size() != longitudinal_bound.size()) {
71 return false;
72 }
73 Eigen::MatrixXd affine_inequality =
74 Eigen::MatrixXd::Zero(4 * t_coord.size(), total_param_);
75 Eigen::MatrixXd affine_boundary =
76 Eigen::MatrixXd::Zero(4 * t_coord.size(), 1);
77 for (uint32_t i = 0; i < t_coord.size(); ++i) {
78 const double d_lateral = SignDistance(ref_point[i], angle[i]);
79 const double d_longitudinal =
80 SignDistance(ref_point[i], angle[i] - M_PI / 2.0);
81 const uint32_t index = FindIndex(t_coord[i]);
82 const double rel_t = t_coord[i] - t_knots_[index];
83 const uint32_t index_offset = 2 * index * (spline_order_ + 1);
84 std::vector<double> longi_coef = AffineCoef(angle[i], rel_t);
85 std::vector<double> longitudinal_coef =
86 AffineCoef(angle[i] - M_PI / 2, rel_t);
87 for (uint32_t j = 0; j < 2 * (spline_order_ + 1); ++j) {
88 // upper longi
89 affine_inequality(4 * i, index_offset + j) = longi_coef[j];
90 // lower longi
91 affine_inequality(4 * i + 1, index_offset + j) = -longi_coef[j];
92 // upper longitudinal
93 affine_inequality(4 * i + 2, index_offset + j) = longitudinal_coef[j];
94 // lower longitudinal
95 affine_inequality(4 * i + 3, index_offset + j) = -longitudinal_coef[j];
96 }
97
98 affine_boundary(4 * i, 0) = d_lateral - lateral_bound[i];
99 affine_boundary(4 * i + 1, 0) = -d_lateral - lateral_bound[i];
100 affine_boundary(4 * i + 2, 0) = d_longitudinal - longitudinal_bound[i];
101 affine_boundary(4 * i + 3, 0) = -d_longitudinal - longitudinal_bound[i];
102 }
103 return AddInequalityConstraint(affine_inequality, affine_boundary);
104}
apollo::planning::Spline2dConstraint::AddInequalityConstraint
bool AddInequalityConstraint(const Eigen::MatrixXd &constraint_matrix, const Eigen::MatrixXd &constraint_boundary)
Definition spline_2d_constraint.cc:44

◆ Add2dDerivativeBoundary()

bool apollo::planning::Spline2dConstraint::Add2dDerivativeBoundary ( const std::vector< double > &  t_coord,
const std::vector< double > &  angle,
const std::vector< apollo::common::math::Vec2d > &  ref_point,
const std::vector< double > &  longitudinal_bound,
const std::vector< double > &  lateral_bound 
)

在文件 spline_2d_constraint.cc 第 106 行定义.

110 {
111 if (t_coord.size() != angle.size() || angle.size() != ref_point.size() ||
112 ref_point.size() != lateral_bound.size() ||
113 lateral_bound.size() != longitudinal_bound.size()) {
114 return false;
115 }
116 Eigen::MatrixXd affine_inequality =
117 Eigen::MatrixXd::Zero(4 * t_coord.size(), total_param_);
118 Eigen::MatrixXd affine_boundary =
119 Eigen::MatrixXd::Zero(4 * t_coord.size(), 1);
120 for (uint32_t i = 0; i < t_coord.size(); ++i) {
121 const double d_lateral = SignDistance(ref_point[i], angle[i]);
122 const double d_longitudinal =
123 SignDistance(ref_point[i], angle[i] - M_PI / 2.0);
124 const uint32_t index = FindIndex(t_coord[i]);
125 const double rel_t = t_coord[i] - t_knots_[index];
126 const uint32_t index_offset = 2 * index * (spline_order_ + 1);
127 std::vector<double> longi_coef = AffineDerivativeCoef(angle[i], rel_t);
128 std::vector<double> longitudinal_coef =
129 AffineDerivativeCoef(angle[i] - M_PI / 2, rel_t);
130 for (uint32_t j = 0; j < 2 * (spline_order_ + 1); ++j) {
131 // upper longi
132 affine_inequality(4 * i, index_offset + j) = longi_coef[j];
133 // lower longi
134 affine_inequality(4 * i + 1, index_offset + j) = -longi_coef[j];
135 // upper longitudinal
136 affine_inequality(4 * i + 2, index_offset + j) = longitudinal_coef[j];
137 // lower longitudinal
138 affine_inequality(4 * i + 3, index_offset + j) = -longitudinal_coef[j];
139 }
140
141 affine_boundary(4 * i, 0) = d_lateral - lateral_bound[i];
142 affine_boundary(4 * i + 1, 0) = -d_lateral - lateral_bound[i];
143 affine_boundary(4 * i + 2, 0) = d_longitudinal - longitudinal_bound[i];
144 affine_boundary(4 * i + 3, 0) = -d_longitudinal - longitudinal_bound[i];
145 }
146 return AddInequalityConstraint(affine_inequality, affine_boundary);
147}

◆ Add2dSecondDerivativeBoundary()

bool apollo::planning::Spline2dConstraint::Add2dSecondDerivativeBoundary ( const std::vector< double > &  t_coord,
const std::vector< double > &  angle,
const std::vector< apollo::common::math::Vec2d > &  ref_point,
const std::vector< double > &  longitudinal_bound,
const std::vector< double > &  lateral_bound 
)

在文件 spline_2d_constraint.cc 第 149 行定义.

153 {
154 if (t_coord.size() != angle.size() || angle.size() != ref_point.size() ||
155 ref_point.size() != lateral_bound.size() ||
156 lateral_bound.size() != longitudinal_bound.size()) {
157 return false;
158 }
159 Eigen::MatrixXd affine_inequality =
160 Eigen::MatrixXd::Zero(4 * t_coord.size(), total_param_);
161 Eigen::MatrixXd affine_boundary =
162 Eigen::MatrixXd::Zero(4 * t_coord.size(), 1);
163 for (uint32_t i = 0; i < t_coord.size(); ++i) {
164 const double d_lateral = SignDistance(ref_point[i], angle[i]);
165 const double d_longitudinal =
166 SignDistance(ref_point[i], angle[i] - M_PI / 2.0);
167 const uint32_t index = FindIndex(t_coord[i]);
168 const double rel_t = t_coord[i] - t_knots_[index];
169 const uint32_t index_offset = 2 * index * (spline_order_ + 1);
170 std::vector<double> longi_coef =
171 AffineSecondDerivativeCoef(angle[i], rel_t);
172 std::vector<double> longitudinal_coef =
173 AffineSecondDerivativeCoef(angle[i] - M_PI / 2, rel_t);
174 for (uint32_t j = 0; j < 2 * (spline_order_ + 1); ++j) {
175 // upper longi
176 affine_inequality(4 * i, index_offset + j) = longi_coef[j];
177 // lower longi
178 affine_inequality(4 * i + 1, index_offset + j) = -longi_coef[j];
179 // upper longitudinal
180 affine_inequality(4 * i + 2, index_offset + j) = longitudinal_coef[j];
181 // lower longitudinal
182 affine_inequality(4 * i + 3, index_offset + j) = -longitudinal_coef[j];
183 }
184
185 affine_boundary(4 * i, 0) = d_lateral - lateral_bound[i];
186 affine_boundary(4 * i + 1, 0) = -d_lateral - lateral_bound[i];
187 affine_boundary(4 * i + 2, 0) = d_longitudinal - longitudinal_bound[i];
188 affine_boundary(4 * i + 3, 0) = -d_longitudinal - longitudinal_bound[i];
189 }
190 return AddInequalityConstraint(affine_inequality, affine_boundary);
191}

◆ Add2dThirdDerivativeBoundary()

bool apollo::planning::Spline2dConstraint::Add2dThirdDerivativeBoundary ( const std::vector< double > &  t_coord,
const std::vector< double > &  angle,
const std::vector< apollo::common::math::Vec2d > &  ref_point,
const std::vector< double > &  longitudinal_bound,
const std::vector< double > &  lateral_bound 
)

在文件 spline_2d_constraint.cc 第 193 行定义.

197 {
198 if (t_coord.size() != angle.size() || angle.size() != ref_point.size() ||
199 ref_point.size() != lateral_bound.size() ||
200 lateral_bound.size() != longitudinal_bound.size()) {
201 return false;
202 }
203 Eigen::MatrixXd affine_inequality =
204 Eigen::MatrixXd::Zero(4 * t_coord.size(), total_param_);
205 Eigen::MatrixXd affine_boundary =
206 Eigen::MatrixXd::Zero(4 * t_coord.size(), 1);
207 for (uint32_t i = 0; i < t_coord.size(); ++i) {
208 const double d_lateral = SignDistance(ref_point[i], angle[i]);
209 const double d_longitudinal =
210 SignDistance(ref_point[i], angle[i] - M_PI / 2.0);
211 const uint32_t index = FindIndex(t_coord[i]);
212 const double rel_t = t_coord[i] - t_knots_[index];
213 const uint32_t index_offset = 2 * index * (spline_order_ + 1);
214 std::vector<double> longi_coef = AffineThirdDerivativeCoef(angle[i], rel_t);
215 std::vector<double> longitudinal_coef =
216 AffineThirdDerivativeCoef(angle[i] - M_PI / 2, rel_t);
217 for (uint32_t j = 0; j < 2 * (spline_order_ + 1); ++j) {
218 // upper longi
219 affine_inequality(4 * i, index_offset + j) = longi_coef[j];
220 // lower longi
221 affine_inequality(4 * i + 1, index_offset + j) = -longi_coef[j];
222 // upper longitudinal
223 affine_inequality(4 * i + 2, index_offset + j) = longitudinal_coef[j];
224 // lower longitudinal
225 affine_inequality(4 * i + 3, index_offset + j) = -longitudinal_coef[j];
226 }
227
228 affine_boundary(4 * i, 0) = d_lateral - lateral_bound[i];
229 affine_boundary(4 * i + 1, 0) = -d_lateral - lateral_bound[i];
230 affine_boundary(4 * i + 2, 0) = d_longitudinal - longitudinal_bound[i];
231 affine_boundary(4 * i + 3, 0) = -d_longitudinal - longitudinal_bound[i];
232 }
233 return AddInequalityConstraint(affine_inequality, affine_boundary);
234}

◆ AddDerivativeSmoothConstraint()

bool apollo::planning::Spline2dConstraint::AddDerivativeSmoothConstraint ( )

在文件 spline_2d_constraint.cc 第 349 行定义.

349 {
350 if (t_knots_.size() < 3) {
351 return true;
352 }
353 Eigen::MatrixXd affine_equality =
354 Eigen::MatrixXd::Zero(4 * (t_knots_.size() - 2), total_param_);
355 Eigen::MatrixXd affine_boundary =
356 Eigen::MatrixXd::Zero(4 * (t_knots_.size() - 2), 1);
357
358 for (uint32_t i = 0; i + 2 < t_knots_.size(); ++i) {
359 const double rel_t = t_knots_[i + 1] - t_knots_[i];
360 const uint32_t num_params = spline_order_ + 1;
361 const uint32_t index_offset = 2 * i * num_params;
362 std::vector<double> power_t = PolyCoef(rel_t);
363 std::vector<double> derivative_t = DerivativeCoef(rel_t);
364 for (uint32_t j = 0; j < num_params; ++j) {
365 affine_equality(4 * i, j + index_offset) = power_t[j];
366 affine_equality(4 * i + 1, j + index_offset) = derivative_t[j];
367 affine_equality(4 * i + 2, j + index_offset + num_params) = power_t[j];
368 affine_equality(4 * i + 3, j + index_offset + num_params) =
369 derivative_t[j];
370 }
371 affine_equality(4 * i, index_offset + 2 * num_params) = -1.0;
372 affine_equality(4 * i + 1, index_offset + 2 * num_params + 1) = -1.0;
373 affine_equality(4 * i + 2, index_offset + 3 * num_params) = -1.0;
374 affine_equality(4 * i + 3, index_offset + 3 * num_params + 1) = -1.0;
375 }
376 return AddEqualityConstraint(affine_equality, affine_boundary);
377}
apollo::planning::Spline2dConstraint::AddEqualityConstraint
bool AddEqualityConstraint(const Eigen::MatrixXd &constraint_matrix, const Eigen::MatrixXd &constraint_boundary)
Definition spline_2d_constraint.cc:51

◆ AddEqualityConstraint()

bool apollo::planning::Spline2dConstraint::AddEqualityConstraint ( const Eigen::MatrixXd &  constraint_matrix,
const Eigen::MatrixXd &  constraint_boundary 
)

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

53 {
54 return equality_constraint_.AddConstraint(constraint_matrix,
55 constraint_boundary);
56}
apollo::planning::AffineConstraint::AddConstraint
bool AddConstraint(const Eigen::MatrixXd &constraint_matrix, const Eigen::MatrixXd &constraint_boundary)
Definition affine_constraint.cc:52

◆ AddInequalityConstraint()

bool apollo::planning::Spline2dConstraint::AddInequalityConstraint ( const Eigen::MatrixXd &  constraint_matrix,
const Eigen::MatrixXd &  constraint_boundary 
)

在文件 spline_2d_constraint.cc 第 44 行定义.

46 {
47 return inequality_constraint_.AddConstraint(constraint_matrix,
48 constraint_boundary);
49}

◆ AddPointAngleConstraint()

bool apollo::planning::Spline2dConstraint::AddPointAngleConstraint ( const double  t,
const double  angle 
)

在文件 spline_2d_constraint.cc 第 278 行定义.

279 {
280 const uint32_t index = FindIndex(t);
281 const uint32_t num_params = spline_order_ + 1;
282 const uint32_t index_offset = index * 2 * num_params;
283 const double rel_t = t - t_knots_[index];
284
285 // add equality constraint
286 Eigen::MatrixXd affine_equality = Eigen::MatrixXd::Zero(1, total_param_);
287 Eigen::MatrixXd affine_boundary = Eigen::MatrixXd::Zero(1, 1);
288 std::vector<double> line_derivative_coef = AffineDerivativeCoef(angle, rel_t);
289 for (uint32_t i = 0; i < line_derivative_coef.size(); ++i) {
290 affine_equality(0, i + index_offset) = line_derivative_coef[i];
291 }
292
293 // add inequality constraint
294 Eigen::MatrixXd affine_inequality = Eigen::MatrixXd::Zero(2, total_param_);
295 const Eigen::MatrixXd affine_inequality_boundary =
296 Eigen::MatrixXd::Zero(2, 1);
297 std::vector<double> t_coef = DerivativeCoef(rel_t);
298 int x_sign = 1;
299 int y_sign = 1;
300 double normalized_angle = fmod(angle, M_PI * 2);
301 if (normalized_angle < 0) {
302 normalized_angle += M_PI * 2;
303 }
304
305 if (normalized_angle > (M_PI / 2) && normalized_angle < (M_PI * 1.5)) {
306 x_sign = -1;
307 }
308
309 if (normalized_angle >= M_PI) {
310 y_sign = -1;
311 }
312
313 for (uint32_t i = 0; i < t_coef.size(); ++i) {
314 affine_inequality(0, i + index_offset) = t_coef[i] * x_sign;
315 affine_inequality(1, i + index_offset + num_params) = t_coef[i] * y_sign;
316 }
317 if (!AddEqualityConstraint(affine_equality, affine_boundary)) {
318 return false;
319 }
320 return AddInequalityConstraint(affine_inequality, affine_inequality_boundary);
321}

◆ AddPointConstraint()

bool apollo::planning::Spline2dConstraint::AddPointConstraint ( const double  t,
const double  x,
const double  y 
)

在文件 spline_2d_constraint.cc 第 236 行定义.

237 {
238 const uint32_t index = FindIndex(t);
239 const double rel_t = t - t_knots_[index];
240 std::vector<double> coef = PolyCoef(rel_t);
241 return AddPointKthOrderDerivativeConstraint(t, x, y, coef);
242}

◆ AddPointSecondDerivativeConstraint()

bool apollo::planning::Spline2dConstraint::AddPointSecondDerivativeConstraint ( const double  t,
const double  ddx,
const double  ddy 
)

在文件 spline_2d_constraint.cc 第 244 行定义.

246 {
247 const size_t index = FindIndex(t);
248 const double rel_t = t - t_knots_[index];
249 std::vector<double> coef = SecondDerivativeCoef(rel_t);
250 return AddPointKthOrderDerivativeConstraint(t, ddx, ddy, coef);
251}

◆ AddPointThirdDerivativeConstraint()

bool apollo::planning::Spline2dConstraint::AddPointThirdDerivativeConstraint ( const double  t,
const double  dddx,
const double  dddy 
)

在文件 spline_2d_constraint.cc 第 253 行定义.

255 {
256 const size_t index = FindIndex(t);
257 const double rel_t = t - t_knots_[index];
258 std::vector<double> coef = ThirdDerivativeCoef(rel_t);
259 return AddPointKthOrderDerivativeConstraint(t, dddx, dddy, coef);
260}

◆ AddSecondDerivativeSmoothConstraint()

bool apollo::planning::Spline2dConstraint::AddSecondDerivativeSmoothConstraint ( )

在文件 spline_2d_constraint.cc 第 380 行定义.

380 {
381 if (t_knots_.size() < 3) {
382 return true;
383 }
384 Eigen::MatrixXd affine_equality =
385 Eigen::MatrixXd::Zero(6 * (t_knots_.size() - 2), total_param_);
386 Eigen::MatrixXd affine_boundary =
387 Eigen::MatrixXd::Zero(6 * (t_knots_.size() - 2), 1);
388
389 for (uint32_t i = 0; i + 2 < t_knots_.size(); ++i) {
390 const double rel_t = t_knots_[i + 1] - t_knots_[i];
391 const uint32_t num_params = spline_order_ + 1;
392 const uint32_t index_offset = 2 * i * num_params;
393 std::vector<double> power_t = PolyCoef(rel_t);
394 std::vector<double> derivative_t = DerivativeCoef(rel_t);
395 std::vector<double> second_derivative_t = SecondDerivativeCoef(rel_t);
396 for (uint32_t j = 0; j < num_params; ++j) {
397 affine_equality(6 * i, j + index_offset) = power_t[j];
398 affine_equality(6 * i + 1, j + index_offset) = derivative_t[j];
399 affine_equality(6 * i + 2, j + index_offset) = second_derivative_t[j];
400 affine_equality(6 * i + 3, j + index_offset + num_params) = power_t[j];
401 affine_equality(6 * i + 4, j + index_offset + num_params) =
402 derivative_t[j];
403 affine_equality(6 * i + 5, j + index_offset + num_params) =
404 second_derivative_t[j];
405 }
406 affine_equality(6 * i, index_offset + 2 * num_params) = -1.0;
407 affine_equality(6 * i + 1, index_offset + 2 * num_params + 1) = -1.0;
408 affine_equality(6 * i + 2, index_offset + 2 * num_params + 2) = -2.0;
409 affine_equality(6 * i + 3, index_offset + 3 * num_params) = -1.0;
410 affine_equality(6 * i + 4, index_offset + 3 * num_params + 1) = -1.0;
411 affine_equality(6 * i + 5, index_offset + 3 * num_params + 2) = -2.0;
412 }
413 return AddEqualityConstraint(affine_equality, affine_boundary);
414}

◆ AddSmoothConstraint()

bool apollo::planning::Spline2dConstraint::AddSmoothConstraint ( )

在文件 spline_2d_constraint.cc 第 324 行定义.

324 {
325 if (t_knots_.size() < 3) {
326 return false;
327 }
328 Eigen::MatrixXd affine_equality =
329 Eigen::MatrixXd::Zero(2 * (t_knots_.size() - 2), total_param_);
330 Eigen::MatrixXd affine_boundary =
331 Eigen::MatrixXd::Zero(2 * (t_knots_.size() - 2), 1);
332 for (uint32_t i = 0; i + 2 < t_knots_.size(); ++i) {
333 const double rel_t = t_knots_[i + 1] - t_knots_[i];
334 const uint32_t num_params = spline_order_ + 1;
335 const uint32_t index_offset = 2 * i * num_params;
336 std::vector<double> power_t = PolyCoef(rel_t);
337
338 for (uint32_t j = 0; j < num_params; ++j) {
339 affine_equality(2 * i, j + index_offset) = power_t[j];
340 affine_equality(2 * i + 1, j + index_offset + num_params) = power_t[j];
341 }
342 affine_equality(2 * i, index_offset + 2 * num_params) = -1.0;
343 affine_equality(2 * i + 1, index_offset + 3 * num_params) = -1.0;
344 }
345 return AddEqualityConstraint(affine_equality, affine_boundary);
346}

◆ AddThirdDerivativeSmoothConstraint()

bool apollo::planning::Spline2dConstraint::AddThirdDerivativeSmoothConstraint ( )

在文件 spline_2d_constraint.cc 第 417 行定义.

417 {
418 if (t_knots_.size() < 3) {
419 return false;
420 }
421 Eigen::MatrixXd affine_equality =
422 Eigen::MatrixXd::Zero(8 * (t_knots_.size() - 2), total_param_);
423 Eigen::MatrixXd affine_boundary =
424 Eigen::MatrixXd::Zero(8 * (t_knots_.size() - 2), 1);
425
426 for (uint32_t i = 0; i + 2 < t_knots_.size(); ++i) {
427 const double rel_t = t_knots_[i + 1] - t_knots_[i];
428 const uint32_t num_params = spline_order_ + 1;
429 const uint32_t index_offset = 2 * i * num_params;
430 std::vector<double> power_t = PolyCoef(rel_t);
431 std::vector<double> derivative_t = DerivativeCoef(rel_t);
432 std::vector<double> second_derivative_t = SecondDerivativeCoef(rel_t);
433 std::vector<double> third_derivative_t = ThirdDerivativeCoef(rel_t);
434 for (uint32_t j = 0; j < num_params; ++j) {
435 affine_equality(8 * i, j + index_offset) = power_t[j];
436 affine_equality(8 * i + 1, j + index_offset) = derivative_t[j];
437 affine_equality(8 * i + 2, j + index_offset) = second_derivative_t[j];
438 affine_equality(8 * i + 3, j + index_offset) = third_derivative_t[j];
439 affine_equality(8 * i + 4, j + index_offset + num_params) = power_t[j];
440 affine_equality(8 * i + 5, j + index_offset + num_params) =
441 derivative_t[j];
442 affine_equality(8 * i + 6, j + index_offset + num_params) =
443 second_derivative_t[j];
444 affine_equality(8 * i + 7, j + index_offset + num_params) =
445 third_derivative_t[j];
446 }
447 affine_equality(8 * i, index_offset + 2 * num_params) = -1.0;
448 affine_equality(8 * i + 1, index_offset + 2 * num_params + 1) = -1.0;
449 affine_equality(8 * i + 2, index_offset + 2 * num_params + 2) = -2.0;
450 affine_equality(8 * i + 3, index_offset + 2 * num_params + 3) = -6.0;
451 affine_equality(8 * i + 4, index_offset + 3 * num_params) = -1.0;
452 affine_equality(8 * i + 5, index_offset + 3 * num_params + 1) = -1.0;
453 affine_equality(8 * i + 6, index_offset + 3 * num_params + 2) = -2.0;
454 affine_equality(8 * i + 7, index_offset + 3 * num_params + 3) = -6.0;
455 }
456 return AddEqualityConstraint(affine_equality, affine_boundary);
457}

◆ equality_constraint()

const AffineConstraint & apollo::planning::Spline2dConstraint::equality_constraint ( ) const

在文件 spline_2d_constraint.cc 第 466 行定义.

466 {
467 return equality_constraint_;
468}

◆ inequality_constraint()

const AffineConstraint & apollo::planning::Spline2dConstraint::inequality_constraint ( ) const

: output interface inequality constraint

在文件 spline_2d_constraint.cc 第 462 行定义.

462 {
463 return inequality_constraint_;
464}
该类的文档由以下文件生成: