#include <spline_2d_kernel.h>

apollo::planning::Spline2dKernel 的协作图:

Public 成员函数
	Spline2dKernel (const std::vector< double > &t_knots, const uint32_t spline_order)

void	AddRegularization (const double regularization_param)

bool	AddKernel (const Eigen::MatrixXd &kernel, const Eigen::MatrixXd &offset, const double weight)

bool	AddKernel (const Eigen::MatrixXd &kernel, const double weight)

Eigen::MatrixXd *	mutable_kernel_matrix ()

Eigen::MatrixXd *	mutable_offset ()

Eigen::MatrixXd	kernel_matrix () const

const Eigen::MatrixXd	offset () const

void	AddDerivativeKernelMatrix (const double weight)

void	AddSecondOrderDerivativeMatrix (const double weight)

void	AddThirdOrderDerivativeMatrix (const double weight)

bool	AddReferenceLineKernelMatrix (const std::vector< double > &t_coord, const std::vector< common::math::Vec2d > &ref_points, const double weight)

详细描述

在文件 spline_2d_kernel.h 第 33 行定义.

构造及析构函数说明

◆ Spline2dKernel()

apollo::planning::Spline2dKernel::Spline2dKernel	(	const std::vector< double > &	t_knots,
		const uint32_t	spline_order
	)

在文件 spline_2d_kernel.cc 第 32 行定义.

    : t_knots_(t_knots), spline_order_(spline_order) {
  total_params_ =
      (t_knots_.size() > 1 ? 2 * (t_knots_.size() - 1) * (1 + spline_order_)
                           : 0);
  kernel_matrix_ = Eigen::MatrixXd::Zero(total_params_, total_params_);
  offset_ = Eigen::MatrixXd::Zero(total_params_, 1);
}

成员函数说明

◆ AddDerivativeKernelMatrix()

void apollo::planning::Spline2dKernel::AddDerivativeKernelMatrix ( const double weight )

在文件 spline_2d_kernel.cc 第 97 行定义.

                                                                  {
  AddNthDerivativeKernelMatrix(1, weight);
}

◆ AddKernel() [1/2]

bool apollo::planning::Spline2dKernel::AddKernel	(	const Eigen::MatrixXd &	kernel,
		const double	weight
	)

在文件 spline_2d_kernel.cc 第 62 行定义.

                                                    {
  Eigen::MatrixXd offset = Eigen::MatrixXd::Zero(kernel.rows(), 1);
  return AddKernel(kernel, offset, weight);
}

◆ AddKernel() [2/2]

bool apollo::planning::Spline2dKernel::AddKernel	(	const Eigen::MatrixXd &	kernel,
		const Eigen::MatrixXd &	offset,
		const double	weight
	)

在文件 spline_2d_kernel.cc 第 49 行定义.

                                                    {
  if (kernel.rows() != kernel.cols() ||
      kernel.rows() != kernel_matrix_.rows() || offset.cols() != 1 ||
      offset.rows() != offset_.rows()) {
    return false;
  }
  kernel_matrix_ += kernel * weight;
  offset_ += offset * weight;
  return true;
}

◆ AddReferenceLineKernelMatrix()

bool apollo::planning::Spline2dKernel::AddReferenceLineKernelMatrix	(	const std::vector< double > &	t_coord,
		const std::vector< common::math::Vec2d > &	ref_points,
		const double	weight
	)

在文件 spline_2d_kernel.cc 第 111 行定义.

                         {
  if (ref_points.size() != t_coord.size()) {
    return false;
  }
 
  for (uint32_t i = 0; i < t_coord.size(); ++i) {
    auto cur_index = find_index(t_coord[i]);
    double cur_rel_t = t_coord[i] - t_knots_[cur_index];
    // update offset
    double offset_coef_x = -ref_points[i].x() * weight;
    double offset_coef_y = -ref_points[i].y() * weight;
    const uint32_t num_params = spline_order_ + 1;
    for (uint32_t j = 0; j < num_params; ++j) {
      offset_(j + (2 * cur_index) * num_params, 0) = offset_coef_x;
      offset_(j + (2 * cur_index + 1) * num_params, 0) = offset_coef_y;
      offset_coef_x *= cur_rel_t;
      offset_coef_y *= cur_rel_t;
    }
 
    // update kernel matrix
    Eigen::MatrixXd ref_kernel(num_params, num_params);
 
    double cur_t = 1.0;
    std::vector<double> power_t;
    for (uint32_t n = 0; n + 1 < 2 * num_params; ++n) {
      power_t.emplace_back(cur_t);
      cur_t *= cur_rel_t;
    }
 
    for (uint32_t r = 0; r < num_params; ++r) {
      for (uint32_t c = 0; c < num_params; ++c) {
        ref_kernel(r, c) = power_t[r + c];
      }
    }
    kernel_matrix_.block((2 * cur_index) * num_params,
                         (2 * cur_index) * num_params, num_params,
                         num_params) += weight * ref_kernel;
    kernel_matrix_.block((2 * cur_index + 1) * num_params,
                         (2 * cur_index + 1) * num_params, num_params,
                         num_params) += weight * ref_kernel;
  }
  return true;
}

◆ AddRegularization()

void apollo::planning::Spline2dKernel::AddRegularization ( const double regularization_param )

在文件 spline_2d_kernel.cc 第 43 行定义.

                                                                        {
  Eigen::MatrixXd id_matrix =
      Eigen::MatrixXd::Identity(kernel_matrix_.rows(), kernel_matrix_.cols());
  kernel_matrix_ += id_matrix * regularization_param;
}

◆ AddSecondOrderDerivativeMatrix()

void apollo::planning::Spline2dKernel::AddSecondOrderDerivativeMatrix ( const double weight )

在文件 spline_2d_kernel.cc 第 101 行定义.

                                                                       {
  AddNthDerivativeKernelMatrix(2, weight);
}

◆ AddThirdOrderDerivativeMatrix()

void apollo::planning::Spline2dKernel::AddThirdOrderDerivativeMatrix ( const double weight )

在文件 spline_2d_kernel.cc 第 105 行定义.

                                                                      {
  AddNthDerivativeKernelMatrix(3, weight);
}

◆ kernel_matrix()

Eigen::MatrixXd apollo::planning::Spline2dKernel::kernel_matrix ( ) const

在文件 spline_2d_kernel.cc 第 74 行定义.

                                                  {
  return kernel_matrix_ * 2.0;
}

◆ mutable_kernel_matrix()

Eigen::MatrixXd * apollo::planning::Spline2dKernel::mutable_kernel_matrix ( )

在文件 spline_2d_kernel.cc 第 68 行定义.

                                                     {
  return &kernel_matrix_;
}

◆ mutable_offset()

Eigen::MatrixXd * apollo::planning::Spline2dKernel::mutable_offset ( )

在文件 spline_2d_kernel.cc 第 72 行定义.

72{ return &offset_; }

◆ offset()

const Eigen::MatrixXd apollo::planning::Spline2dKernel::offset ( ) const

在文件 spline_2d_kernel.cc 第 78 行定义.

78{ return offset_; }

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

modules/planning/planning_base/math/smoothing_spline/spline_2d_kernel.h
modules/planning/planning_base/math/smoothing_spline/spline_2d_kernel.cc

Public 成员函数