RANSAC 和最小二乘法实现雷达自我速度估计

最新推荐文章于 2024-10-01 04:50:10 发布
最新推荐文章于 2024-10-01 04:50:10 发布
阅读量1k 收藏 23
点赞数 30
分类专栏： RADAR 文章标签： 最小二乘法 算法 机器学习 reve radar
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40301351/article/details/141303571
版权

        在自动驾驶和机器人技术中，雷达（RADAR）是关键的传感器之一，广泛用于检测周围物体的位置和速度。本文将深入探讨如何通过 C++ 代码实现雷达自我速度估计。代码结合了 RANSAC（随机采样一致性算法）和最小二乘法，展示了在含噪声的数据中如何进行准确的速度估计。

背景

        雷达自我速度估计涉及从雷达点云数据中提取有用的信息来计算物体的速度。为了提高估计的鲁棒性和准确性，文献[1]利用RANSAC 和最小二乘法估计雷达自身速度。以下是对代码中主要功能的详细讲解。（完成代码在后面）

代码结构

本文的代码实现包含两个主要部分：

  1. estimate 函数：处理雷达扫描数据并进行速度估计。
  2. solve3DFullRansac 和 solve3DFull 函数：使用 RANSAC 和最小二乘法进行速度估计。

1. estimate 函数

这个函数的主要任务是从雷达数据中提取有效的目标，并进行速度估计。以下是函数的代码及其中文注释：

bool RadarEgoVelocityEstimator::estimate(const sensor_msgs::PointCloud2& radar_scan_msg,
                                         Vector3& v_r,
                                         Vector3& sigma_v_r,
                                         sensor_msgs::PointCloud2& inlier_radar_msg,
                                         sensor_msgs::PointCloud2& outlier_radar_msg)
{
  // 创建点云指针以存储雷达点云数据
  auto radar_scan(new pcl::PointCloud<RadarPointCloudType>);
  auto radar_scan_inlier(new pcl::PointCloud<RadarPointCloudType>);
  auto radar_scan_outlier(new pcl::PointCloud<RadarPointCloudType>);

  std::cout << "雷达扫描消息大小: " << radar_scan_msg.width << std::endl;

  bool success = false;
  // 从 ROS 消息中提取点云数据
  pcl::fromROSMsg(radar_scan_msg, *radar_scan);

  std::vector<Vector11> valid_targets;
  // 遍历点云数据，筛选出有效的目标
  for (uint i = 0; i < radar_scan->size(); ++i)
  {
    const auto target = radar_scan->at(i);
    const double r      = Vector3(target.x, target.y, target.z).norm();
    Real azimuth   = std::atan2(target.y, target.x);
    Real elevation = std::atan2(std::sqrt(target.x * target.x + target.y * target.y), target.z) - M_PI_2;

    // 根据距离、强度、方位角和俯仰角筛选有效目标
    if (r > config_.min_dist && r < config_.max_dist && target.intensity > config_.min_db &&
        std::fabs(azimuth) < angles::from_degrees(config_.azimuth_thresh_deg) &&
        std::fabs(elevation) < angles::from_degrees(config_.elevation_thresh_deg))
    {
      Vector11 v_pt;
      v_pt << target.x, target.y, target.z, target.intensity, -target.doppler * config_.doppler_velocity_correction_factor,
              r, azimuth, elevation, target.x / r, target.y / r, target.z / r;
      valid_targets.emplace_back(v_pt);
    }
  }
  std::cout << "有效目标数量: " << valid_targets.size() << std::endl;

  // 如果有效目标的数量超过两个，进行速度估计
  if (valid_targets.size() > 2)
  {
    std::vector<double> v_dopplers;
    // 提取每个目标的多普勒速度
    for (const auto& v_pt : valid_targets) v_dopplers.emplace_back(std::fabs(v_pt[idx_.doppler]));
    const size_t n = v_dopplers.size() * (1.0 - config_.allowed_outlier_percentage);
    std::nth_element(v_dopplers.begin(), v_dopplers.begin() + n, v_dopplers.end());
    const auto median = v_dopplers[n];
    
    // 如果中位数速度小于阈值，则认为速度接近零
    if (median < config_.thresh_zero_velocity)
    {
      v_r = Vector3(0, 0, 0);
      sigma_v_r = Vector3(config_.sigma_zero_velocity_x, config_.sigma_zero_velocity_y, config_.sigma_zero_velocity_z);
      for (const auto& item : valid_targets)
        if (std::fabs(item[idx_.doppler]) < config_.thresh_zero_velocity)
          radar_scan_inlier->push_back(toRadarPointCloudType(item, idx_));
      success = true;
    }
    else
    {
      Matrix radar_data(valid_targets.size(), 4);
      uint idx = 0;
      // 将有效目标数据填充到矩阵中
      for (const auto& v_pt : valid_targets)
        radar_data.row(idx++) = Vector4(v_pt[idx_.normalized_x], v_pt[idx_.normalized_y], v_pt[idx_.normalized_z], v_pt[idx_.doppler]);

      // 使用 RANSAC 或最小二乘法进行速度估计
      if (config_.use_ransac)
      {
        std::vector<uint> inlier_idx_best;
        std::vector<uint> outlier_idx_best;
        success = solve3DFullRansac(radar_data, v_r, sigma_v_r, inlier_idx_best, outlier_idx_best);
        // 根据内点和外点更新点云数据
        for (const auto& idx : inlier_idx_best)
          radar_scan_inlier->push_back(toRadarPointCloudType(valid_targets.at(idx), idx_));
        for (const auto& idx : outlier_idx_best)
          radar_scan_outlier->push_back(toRadarPointCloudType(valid_targets.at(idx), idx_));
      }
      else
      {
        for (const auto& item : valid_targets) radar_scan_inlier->push_back(toRadarPointCloudType(item, idx_));
        success = solve3DFull(radar_data, v_r, sigma_v_r);
      }
    }
  }
  else ROS_INFO("有效目标数量太小（< 2）");

  // 将内点和外点的点云数据转换为 ROS 消息
  radar_scan_inlier->height = 1;
  radar_scan_inlier->width  = radar_scan_inlier->size();

  pcl::PCLPointCloud2 tmp;
  pcl::toPCLPointCloud2<RadarPointCloudType>(*radar_scan_inlier, tmp);
  pcl_conversions::fromPCL(tmp, inlier_radar_msg);
  inlier_radar_msg.header = radar_scan_msg.header;

  radar_scan_outlier->height = 1;
  radar_scan_outlier->width  = radar_scan_outlier->size();

  pcl::PCLPointCloud2 tmp_o;
  pcl::toPCLPointCloud2<RadarPointCloudType>(*radar_scan_outlier, tmp_o);
  pcl_conversions::fromPCL(tmp_o, outlier_radar_msg);
  outlier_radar_msg.header = radar_scan_msg.header;

  return success;
}

2. solve3DFullRansac 函数

solve3DFullRansac 函数在处理雷达数据时，使用了 RANSAC（随机样本一致性算法）来提高估计的鲁棒性，尤其是在数据中可能存在异常值的情况下。RANSAC 是一种迭代方法，用于从包含噪声的数据中估计模型参数。该函数的目的是通过 RANSAC 算法找到最佳的速度估计，并将数据分为内点（inliers）和外点（outliers）。

函数代码
bool RadarEgoVelocityEstimator::solve3DFullRansac(const Matrix& radar_data,
                                                  Vector3& v_r,
                                                  Vector3& sigma_v_r,
                                                  std::vector<uint>& inlier_idx_best,
                                                  std::vector<uint>& outlier_idx_best)
{
  // 构建设计矩阵 H
  Matrix H_all(radar_data.rows(), 3);
  H_all.col(0) = radar_data.col(0); // x 分量
  H_all.col(1) = radar_data.col(1); // y 分量
  H_all.col(2) = radar_data.col(2); // z 分量
  const Vector y_all = radar_data.col(3); // 多普勒速度数据

  // 创建索引列表用于 RANSAC 迭代
  std::vector<uint> idx(radar_data.rows());
  for (uint k = 0; k < radar_data.rows(); ++k) idx[k] = k;

  std::random_device rd;
  std::mt19937 g(rd());

  if (radar_data.rows() >= config_.N_ransac_points)
  {
    for (uint k = 0; k < ransac_iter_; ++k)
    {
      std::shuffle(idx.begin(), idx.end(), g); // 随机打乱数据索引
      Matrix radar_data_iter;
      radar_data_iter.resize(config_.N_ransac_points, 4);

      for (uint i = 0; i < config_.N_ransac_points; ++i) radar_data_iter.row(i) = radar_data.row(idx.at(i));
      bool rtn = solve3DFull(radar_data_iter, v_r, sigma_v_r, false);
      if (rtn == false) ROS_INFO("Failure at solve3DFullRansac() 1");
      if (rtn)
      {
        const Vector err = (y_all - H_all * v_r).array().abs();
        std::vector<uint> inlier_idx;
        std::vector<uint> outlier_idx;
        for (uint j = 0; j < err.rows(); ++j)
        {
          if (err(j) < config_.inlier_thresh)
            inlier_idx.emplace_back(j); // 识别内点
          else
            outlier_idx.emplace_back(j); // 识别外点
        }
        // 如果外点比例过高，将外点视为内点
        if ( float(outlier_idx.size())/(inlier_idx.size()+outlier_idx.size()) > 0.05 )
        {
          inlier_idx.insert(inlier_idx.end(), outlier_idx.begin(), outlier_idx.end());
          outlier_idx.clear();
        }

        // 更新最佳内点和外点索引
        if (inlier_idx.size() > inlier_idx_best.size())
        {
          inlier_idx_best = inlier_idx;
        }
        if (outlier_idx.size() > outlier_idx_best.size())
        {
          outlier_idx_best = outlier_idx;
        }
      }
    }
  }
  else
  {
    ROS_INFO("Warning: radar_data.rows() < config_.N_ransac_points");
  }

  // 如果找到了内点
  if (!inlier_idx_best.empty())
  {
    Matrix radar_data_inlier(inlier_idx_best.size(), 4);
    for (uint i = 0; i < inlier_idx_best.size(); ++i) radar_data_inlier.row(i) = radar_data.row(inlier_idx_best.at(i));
    
    bool rtn = solve3DFull(radar_data_inlier, v_r, sigma_v_r, true);
    if (rtn == false) ROS_INFO("Failure at solve3DFullRansac() 2");
    return rtn;
  }
  ROS_INFO("Failure at solve3DFullRansac() 3");
  return false;
}
函数解析

1. 构建设计矩阵：

Matrix H_all(radar_data.rows(), 3);
H_all.col(0) = radar_data.col(0);
H_all.col(1) = radar_data.col(1);
H_all.col(2) = radar_data.col(2);
const Vector y_all = radar_data.col(3);

 从 radar_data 中提取 x、y、z 分量，并构建完整的设计矩阵 H_all。

2. 初始化 RANSAC 参数：

std::vector<uint> idx(radar_data.rows());
for (uint k = 0; k < radar_data.rows(); ++k) idx[k] = k;
std::random_device rd;
std::mt19937 g(rd());

创建索引列表用于 RANSAC 迭代，并初始化随机数生成器。

3. RANSAC 迭代：

for (uint k = 0; k < ransac_iter_; ++k)
{
  std::shuffle(idx.begin(), idx.end(), g);
  Matrix radar_data_iter;
  radar_data_iter.resize(config_.N_ransac_points, 4);
  for (uint i = 0; i < config_.N_ransac_points; ++i) radar_data_iter.row(i) = radar_data.row(idx.at(i));
  bool rtn = solve3DFull(radar_data_iter, v_r, sigma_v_r, false);
  // 计算残差并分离内点和外点
}

随机选择 N_ransac_points 个点进行最小二乘估计，并计算每个点的残差，将其分为内点和外点。根据内点和外点的数量更新最佳的内点和外点索引。

4. 最终估计：

if (!inlier_idx_best.empty())
{
  Matrix radar_data_inlier(inlier_idx_best.size(), 4);
  for (uint i = 0; i < inlier_idx_best.size(); ++i) radar_data_inlier.row(i) = radar_data.row(inlier_idx_best.at(i));
  bool rtn = solve3DFull(radar_data_inlier, v_r, sigma_v_r, true);
  return rtn;
}

 如果找到了内点，使用这些内点数据进行最终的最小二乘估计。

3.solve3DFull 函数详解

solve3DFull 函数是最小二乘法的核心实现，负责从雷达数据中解算速度。它通过构建设计矩阵并解线性方程来估计目标速度，并可以选择性地计算标准差。

函数代码
bool RadarEgoVelocityEstimator::solve3DFull(const Matrix& radar_data,
                                            Vector3& v_r,
                                            Vector3& sigma_v_r,
                                            bool estimate_sigma)
{
  // 构建设计矩阵 H
  Matrix H(radar_data.rows(), 3);
  H.col(0) = radar_data.col(0); // x 分量
  H.col(1) = radar_data.col(1); // y 分量
  H.col(2) = radar_data.col(2); // z 分量
  const Matrix HTH = H.transpose() * H; // 计算 H^T * H

  const Vector y = radar_data.col(3); // 多普勒速度数据

  // 使用 SVD (奇异值分解) 来解决最小二乘问题
  Eigen::JacobiSVD<Matrix> svd(HTH);
  Real cond = svd.singularValues()(0) / svd.singularValues()(svd.singularValues().size() - 1);

  // 检查条件数是否合理，避免数值不稳定
  if (1)//std::fabs(cond) < 1.0e3
  {
    // 选择 Cholesky 分解或 SVD 计算速度
    if (config_.use_cholesky_instead_of_bdcsvd)
    {
      v_r = (HTH).ldlt().solve(H.transpose() * y);
    }
    else
    {
      v_r = H.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(y);
    }

    // 如果需要估计误差的标准差
    if (estimate_sigma)
    {
      // 计算估计误差
      const Vector e = H * v_r - y;
      const Matrix C = (e.transpose() * e).x() * (HTH).inverse() / (H.rows() - 3); // 计算协方差矩阵
      sigma_v_r = Vector3(C(0, 0), C(1, 1), C(2, 2)); // 提取对角线元素
      sigma_v_r = sigma_v_r.array(); // 转换为数组形式

      // 确保标准差非负，并应用偏移量
      if (sigma_v_r.x() >= 0.0 && sigma_v_r.y() >= 0.0 && sigma_v_r.z() >= 0.)
      {
        sigma_v_r = sigma_v_r.array().sqrt(); // 对标准差取平方根
        sigma_v_r += Vector3(config_.sigma_offset_radar_x, config_.sigma_offset_radar_y, config_.sigma_offset_radar_z); // 添加偏移量
        // 检查标准差是否在允许范围内
        if (sigma_v_r.x() < config_.max_sigma_x && sigma_v_r.y() < config_.max_sigma_y &&
            sigma_v_r.z() < config_.max_sigma_z)
        {
          return true; // 如果标准差合理，返回成功
        }
      }
    }
    else
    {
      return true; // 如果不需要估计标准差，直接返回成功
    }
  }
  // 如果条件数过大，可能说明计算不稳定
  //ROS_INFO("cond too large, cond = %f", cond);

  return true; // 返回成功标志
}

函数解析

1. 构建设计矩阵：

Matrix H(radar_data.rows(), 3);
H.col(0) = radar_data.col(0);
H.col(1) = radar_data.col(1);
H.col(2) = radar_data.col(2);
const Matrix HTH = H.transpose() * H;

从雷达数据中提取 x、y 和 z 分量，并构建设计矩阵 H。计算 H^T * H 为后续的求解做准备。

2. 奇异值分解： 

Eigen::JacobiSVD<Matrix> svd(HTH);
Real cond = svd.singularValues()(0) / svd.singularValues()(svd.singularValues().size() - 1);

对 H^T * H 进行奇异值分解，并计算条件数 cond。条件数用于判断矩阵的数值稳定性。

3. 选择分解方法： 

if (config_.use_cholesky_instead_of_bdcsvd)
{
  v_r = (HTH).ldlt().solve(H.transpose() * y);
}
else
{
  v_r = H.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(y);
}

根据配置选择 Cholesky 分解或 BDCSVD 分解来计算速度向量 v_r。

4. 估计标准差： 

if (estimate_sigma)
{
  const Vector e = H * v_r - y;
  const Matrix C = (e.transpose() * e).x() * (HTH).inverse() / (H.rows() - 3);
  sigma_v_r = Vector3(C(0, 0), C(1, 1), C(2, 2));
  sigma_v_r = sigma_v_r.array();
  if (sigma_v_r.x() >= 0.0 && sigma_v_r.y() >= 0.0 && sigma_v_r.z() >= 0.)
  {
    sigma_v_r = sigma_v_r.array().sqrt();
    sigma_v_r += Vector3(config_.sigma_offset_radar_x, config_.sigma_offset_radar_y, config_.sigma_offset_radar_z);
    if (sigma_v_r.x() < config_.max_sigma_x && sigma_v_r.y() < config_.max_sigma_y &&
        sigma_v_r.z() < config_.max_sigma_z)
    {
      return true;
    }
  }
}

如果需要估计标准差，计算误差的协方差矩阵，并将其转换为标准差。如果标准差在允许范围内，则返回成功。

总结

  • solve3DFullRansac 函数利用 RANSAC 算法来处理含有噪声和异常值的数据，选择最佳的内点集合进行速度估计，从而提高估计的鲁棒性。
  • solve3DFull 函数使用最小二乘法直接从雷达数据中计算速度，并根据需要估计误差的标准差。

通过结合这两个函数，可以有效地从雷达数据中估计目标的速度，并处理数据中的异常值和噪声问题。

 

[1] Doer C, Trommer G F. An ekf based approach to radar inertial odometry[C]//2020 IEEE International Conference on Multisensor Fusion and Integration for Intelligent Systems (MFI). IEEE, 2020: 152-159.

代码连接：https://github.com/christopherdoer/reve

CSDN下载https://download.csdn.net/download/qq_40301351/89649333

点云兔子
关注
专栏目录
关于点云Point Cloud、VoxelGrid、RANSAC、DBSCAN 和 ICP 的注释
iCloudEnd的博客
08-02 40
点云是位于三维空间中的一组点。每个点通常由 x、y 和 z 坐标定义，有时可能具有其他属性，例如颜色 (RGB) 或强度。点云通常使用激光雷达、声纳、雷达和立体摄像机等传感器获取。3D 扫描和建模涉及建筑结构、历史文物和工业产品的数字扫描和建模。它用于各种领域，例如：自动驾驶汽车：利用环境感知检测障碍物和道路。机器人：环境测绘和导航。考古学：考古遗址和发现的数字分析和记录。点云通常是大型数据集，并且使用各种技术和算法来处理、分析和可视化这些数据。
雷达图像基本参数计算文献_RASR_NESZ_雷达_aasr_
10-01
两篇文献中，显示说明了如何计算NESZ AASR RASR
【阅读】Wheel extraction based on micro doppler distribution using high-resolution radar
weixin_43152152的博客
01-14 1002
基于高分辨率雷达的微多普勒分布的车轮提取 1 前要 本文知识点主要包括：毫米波雷达原理、多普勒效应、微多普勒效应、DBSCAN、RANSAC 1.1 毫米波雷达原理 偏雷达硬件底层算法 多普勒效应 波源和观察对象有相对运动时，观察者接收到波的频率和波源发射的频率并不相同的现象。 靠近时，观察者接收和反射的频率变高；远离时，观察者接收和反射的频率变低。 微多普勒效应 非刚体系统内部组件的微运动使得雷达回波中包含表征这些组件运动的多普勒信息（可以理解为微运动对雷达波的频率调制），称之为微多普勒。 例
(三) 三维点云课程---RANSAC结合最小二乘求解点云的地面
qq_45369294的博客
10-28 1540
三维点云课程—RANSAC结合最小二乘求解点云的地面 三维点云课程---RANSAC结合最小二乘求解点云的地面三维点云课程---RANSAC结合最小二乘求解点云的地面1.RANSAC的步骤2.RANCAC的代码分析2.1输入参数τ，N\tau，Nτ，N的分析2.2 平面模型的创建2.3统计内点的个数2.4最小二乘优化2.5提前终止RANSAC的迭代3.RANSAC完整代码**原始数据** ![在这里插入图片描述](https://img-blog.csdnimg.cn/d10228f8bf3d4c5c978
使用雷达速度因子进行越野导航的鲁棒高速状态估计
点云兔子的博客
09-19 1046
在复杂环境中实现机器人自主性以用于关键任务应用需要鲁棒的状态估计。特别是在导航所依赖的外感传感器可能因环境挑战而退化，从而导致任务失败的情况下。这种情况下，调频连续波（FMCW）雷达传感器的潜力得以凸显：作为一种具有直接速度测量能力的补充外感传感方式。在这项工作中，我们整合了FMCW雷达传感器的径向速度测量，使用径向速度因子提供线速度更新，并将其融合到滑动窗口状态估计器中，以与LiDAR姿态和IMU测量相结合。
【图像拼接】基于SIFT描述符和RANSAC算法实现多图图像拼接系统Matlab代码
m0_57702748的博客
05-29 1192
​图像拼接是指将多幅图像拼接成一张全景图像，它在计算机视觉领域有着广泛的应用，例如全景照片拍摄、虚拟现实、医学图像处理等。图像拼接的实现需要解决两个关键问题：特征匹配和图像配准。特征匹配是指在不同图像中找到相同的特征点，而图像配准则是将不同图像中的对应点进行对齐。本文将介绍一种基于SIFT描述符和RANSAC算法实现多图图像拼接系统的方案。一、SIFT 描述符。
MULLS：一种基于多尺度线性最小二乘的激光SLAM算法
3D视觉工坊
02-17 1395
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达作者丨paopaoslam来源丨泡泡机器人SLAM标题：MULLS: Versatile LiDAR SLAM via Multi-...
大盘点！汇总点云分割算法，涉及RANSAC、欧式聚类、区域增长等
3D视觉工坊
08-29 6254
作者：PCIPG-zzl | 来源：计算机视觉工坊添加微信：dddvisiona，备注：3D点云，拉你入群。文末附行业细分群。1 什么是点云分割点云分割的目标是将点云数据中的点分成不同的组或类别，使每个组中的点都属于同一种物体或区域。根据空间，几何和纹理等特征对点云进行划分，使同一划分内的点云拥有相似的特征。点云分割的目的是分块，从而便于单独处理。分割过程有助于从各个方面分析场景，例如定位和识别对...
激光雷达数据处理,激光雷达数据处理流程,matlab
05-05
MATLAB提供了多种模型拟合和验证工具，比如最小二乘法、RANSAC算法等，可以帮助我们建立有效的点云处理模型。 最后，三维表面拟合是对激光雷达数据的高级应用，它可以生成地形表面、建筑物等的精确3D模型。MATLAB中...
激光雷达数据处理.rar
05-05
1. **激光雷达数据**：激光雷达是一种远程感知技术，通过发射激光脉冲并测量其反射时间来确定目标的距离、速度和形状。它广泛应用于自动驾驶、地形测绘、环境监测等领域。数据通常以点云的形式存储，每个点包含位置...
3D雷达路测点云数据
06-12
然后，可以应用曲线拟合（如最小二乘法）或表面拟合（如泊松表面重建）方法，将点云数据转换成几何模型，帮助我们理解和描述环境中的物体。 在软件开发中，3D雷达路测点云数据的应用非常广泛。例如，它可以用于训练...
（2-2-2）LiDAR激光雷达传感器感知：点云处理（2）法向量估计（Normal Estimation）+曲面重建（Surface Reconstruction）+配准（Registration）算
码农三叔
08-21 950
配准的目的是将多个时刻或不同传感器获取的点云进行匹配，实现点云的对齐。例如下面是一个简单的例子，功能是使用自定义实现的ICP 算法处理LiDAR 点云数据。基于网格的曲面重建（例如Poisson重建）算法通常将点云数据划分为体素（三维像素）的网格，然后在每个体素内估计曲面形状。例如下面是一个简单的例子，演示了自定义实现基于体素的曲面重建算法，并在LiDAR点云数据上应用的过程。基于网格的曲面重建算法利用点云数据生成三角网格模型，并通过网格上的插值或拟合来获得曲面模型的一种方法。图2-6 可视化点云。
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1272
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 461
25[0, 105]
904. 水果成篮
YQ20210216的博客
09-27 358
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
最新发布
m0_57859086的博客
10-01 762
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
RANSAC与最小二乘法结合的点云平面拟合算法
而RANSAC结合最小二乘法的算法在处理含有误差和异常值的点云数据时，表现出更好的稳健性，能够稳定地得到较好的平面参数估计。 这篇论文的研究结果表明，结合RANSAC和最小二乘法的平面拟合算法在处理点云数据时具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

点云兔子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值