(02)Cartographer源码无死角解析-(82) 轨迹结束处理Node::FinishTrajectoryUnderLock()、最后一次优化RunFinalOptimization()

Cartographer源码理解 cartographer源码理解与仿真环境配置 阅读详情

讲解关于slam一系列文章汇总链接:史上最全slam从零开始,针对于本栏目讲解(02)Cartographer源码无死角解析-链接如下:
(02)Cartographer源码无死角解析- (00)目录_最新无死角讲解:https://blog.csdn.net/weixin_43013761/article/details/127350885
 
文末正下方中心提供了本人 联系方式, 点击本人照片即可显示 W X → 官方认证 {\color{blue}{文末正下方中心}提供了本人 \color{red} 联系方式,\color{blue}点击本人照片即可显示WX→官方认证} 文末正下方中心提供了本人联系方式,点击本人照片即可显示WX→官方认证
 

一、前言

通过前面几篇博客,对于 ROS 订阅服务,发布消息,最后通过 Rviz 进行可视化的过程应该算是比较熟悉了,特别是关于各个坐标系之间的关系,有了比较深的理解。下面来讲解一些收尾工作,比如建图完成之后,需要做什么处理,轨迹与地图是如何保存的,保存好之后应该如何加载,以及重定位模式等等。

该篇博客先首先来看看建图完成之后做了那些处理,先回到 src/cartographer_ros/cartographer_ros/cartographer_ros/node_main.cc 这个文件,可以看到如下代码:

	......
	// 使用默认topic 开始轨迹
	if (FLAGS_start_trajectory_with_default_topics) {
  		node.StartTrajectoryWithDefaultTopics(trajectory_options);
	}
	
	::ros::spin();
	
	// 结束所有处于活动状态的轨迹
	node.FinishAllTrajectories();
	
	// 当所有的轨迹结束时, 再执行一次全局优化
	node.RunFinalOptimization();
	
	// 如果save_state_filename非空, 就保存pbstream文件
	if (!FLAGS_save_state_filename.empty()) {
  		node.SerializeState(FLAGS_save_state_filename,
	                        true /* include_unfinished_submaps */);
	}

再轨迹开始之后会阻塞在 ::ros::spin(); 这个位姿,期间会等待接收数据,收到数据执行回调函数利用数据进行建图与定位。只有 ctrl + c 结束进程或者通过 ROS 内置的其他方式,比如建图完成,才会跳过阻塞执行 ::ros::spin() 之后的函数,如 node.FinishAllTrajectories();、node.RunFinalOptimization() 等。

首先的疑问是,除 ctrl + c 结束进程以外,还有什么方式让 ::ros::spin() 阻塞停止,接着往下运行。据本人观察,即使数据集播放完毕,其也依旧阻塞,不过其存在一个服务,通过指令的方式,告诉 cartographer 目前已经完成建图了,可以停止了,该服务依旧位于 node.cc 这个文件,构造函数的如下代码:

      kFinishTrajectoryServiceName, &Node::HandleFinishTrajectory, this));
  service_servers_.push_back(node_handle_.advertiseService(

当通过服务 “finish_trajectory” 接收到客户端指令时,会回调 Node::HandleFinishTrajectory() 这个函数,该函数会根据传入的参数结束轨迹:

/**
 * @brief 结束一条轨迹
 *
 * @param[in] request 轨迹的id
 * @param[out]] response 返回StatusResponse格式的处理状态
 * @return true
 */
bool Node::HandleFinishTrajectory(
    ::cartographer_ros_msgs::FinishTrajectory::Request& request,
    ::cartographer_ros_msgs::FinishTrajectory::Response& response) {
  absl::MutexLock lock(&mutex_);
  response.status = FinishTrajectoryUnderLock(request.trajectory_id);
  return true;
}

可以看到,服务传递的参数就是一个 trajectory_id,还是十分简单的,上锁之后会进一步调用 Node::FinishTrajectoryUnderLock() 这个函数。

二、Node::FinishTrajectoryUnderLock()

( 1 ) : \color{blue}(1): (1): 其首先在 Node::trajectories_scheduled_for_finish_ 这个成员变量中查询一下 trajectory_id 是否已经准备结束了,如果是则打印一下信息,且返回 OK 的状态码,主要目的是放置客户端发送多次取消同一轨迹的情况。

( 2 ) : \color{blue}(2): (2): 接着调用 Node::TrajectoryStateToStatus 函数,首先查询一下轨迹是否存在,如果不存在则返回且告诉知客户,其指定的轨迹不存在。如果存在且为 TrajectoryState::ACTIVE 状态,则返回 StatusCode::OK 否则返回 StatusCode::INVALID_ARGUMENT,且告知客户端无法完成该轨迹,其是如何具体查询状态的,后续我们再进行分析。

( 3 ) : \color{blue}(3): (3): 如果为 TrajectoryState::ACTIVE 状态,则判断一下该轨迹是否书否存在订阅者,如有,则关闭,且从 subscribers_ 中擦除该轨迹相关信息。

( 4 ) : \color{blue}(4): (4): 调用cartographer中map_builder的FinishTrajectory()进行轨迹的结束,且结束之后把 trajectory_id 放置在 trajectories_scheduled_for_finish_ 之中,避免后续被重复结束。然后返回 StatusCode::OK 标识,标识正常结束该轨迹。

/**
 * @brief 结束指定id的轨迹
 *
 * @param[in] trajectory_id 要结束的轨迹的id
 * @return cartographer_ros_msgs::StatusResponse
 */
cartographer_ros_msgs::StatusResponse Node::FinishTrajectoryUnderLock(
    const int trajectory_id) {
  cartographer_ros_msgs::StatusResponse status_response;
  // Step: 1 检查 trajectory_id 是否在 正在结束的轨迹集合中
  if (trajectories_scheduled_for_finish_.count(trajectory_id)) {
    status_response.message = absl::StrCat("Trajectory ", trajectory_id,
                                           " already pending to finish.");
    status_response.code = cartographer_ros_msgs::StatusCode::OK;
    LOG(INFO) << status_response.message;
    return status_response;
  }

  // First, check if we can actually finish the trajectory.
  // Step: 2 检查这个轨迹是否存在, 如果存在则检查这个轨迹是否是ACTIVE状态
  status_response = TrajectoryStateToStatus(
      trajectory_id, {TrajectoryState::ACTIVE} /* valid states */);
  // 如果不是OK状态就返回ERROR
  if (status_response.code != cartographer_ros_msgs::StatusCode::OK) {
    LOG(ERROR) << "Can't finish trajectory: " << status_response.message;
    return status_response;
  }

  // Shutdown the subscribers of this trajectory.
  // A valid case with no subscribers is e.g. if we just visualize states.
  // Step: 3 如果这个轨迹存在subscribers, 则先关闭subscriber
  if (subscribers_.count(trajectory_id)) {
    for (auto& entry : subscribers_[trajectory_id]) {
      entry.subscriber.shutdown();
      subscribed_topics_.erase(entry.topic);
      LOG(INFO) << "Shutdown the subscriber of [" << entry.topic << "]";
    }
    // 在subscribers_中将这条轨迹的信息删除
    CHECK_EQ(subscribers_.erase(trajectory_id), 1);
  }

  // Step: 4 调用cartographer中的map_builder的FinishTrajectory()进行轨迹的结束
  map_builder_bridge_.FinishTrajectory(trajectory_id);
  // 将这个轨迹id放进正在结束的轨迹集合中
  trajectories_scheduled_for_finish_.emplace(trajectory_id);
  status_response.message =
      absl::StrCat("Finished trajectory ", trajectory_id, ".");
  status_response.code = cartographer_ros_msgs::StatusCode::OK;
  return status_response;
}

根据该函数,可以知道,通过服务的方式,可以控制轨迹的结束,所以可以再终端运行指令 rosservice call /finish_trajectory 0 结束轨迹。

三、 Node::TrajectoryStateToStatus()

现在回过头来看看,这个函数是如何获取轨迹状态的,其核心在于调用了

const auto trajectory_states = map_builder_bridge_.GetTrajectoryStates();

再深入之前,先来看看 trajectory_states 的类型,如下:

std::map<int, ::cartographer::mapping::PoseGraphInterface::TrajectoryState>

其用于标记每条轨迹目前的状态,轨迹的状态共有如下几种:

  enum class TrajectoryState { ACTIVE, FINISHED, FROZEN, DELETED };

分别表示活跃,完成、冻结 以及 删除。MapBuilderBridge::GetTrajectoryStates() 这个函数函数也不会复杂,其主要从 map_builder_ 的后端获取轨迹的状态:

	auto trajectory_states = map_builder_->pose_graph()->GetTrajectoryStates();

通过查看 PoseGraph2D::GetTrajectoryStates() 可以知道,Node::map_builder_bridge_::map_builder_::pose_graph_::data_.trajectories_state中存储了所有轨迹的状态,在 pose_graph_2d.cc 文件中搜索可以 data_.trajectories_state 可知其在这些函数中被引用:

PoseGraph2D::AddTrajectoryIfNeeded() //把轨迹添加到连接状态里,同时为轨迹创建采样器
PoseGraph2D::DeleteTrajectoriesIfNeeded() //如果轨迹处于等待删除状态则会对其进行删除
PoseGraph2D::DeleteTrajectory(const int trajectory_id) //根据 trajectory_id 删除轨迹,主要更改 data_.trajectories_state 中的轨迹状态
PoseGraph2D::FinishTrajectory(const int trajectory_id) //轨迹完成时,会把轨迹状态标记为完成
PoseGraph2D::IsTrajectoryFinished(const int trajectory_id) // 根据 data_.trajectories_state 获取轨迹的状态
PoseGraph2D::IsTrajectoryFrozen(const int trajectory_id) //判断轨迹是否为冻结状态
PoseGraph2D::CanAddWorkItemModifying(int trajectory_id) //判断是否可以往该轨迹添加数据,只有活跃的轨迹才能添加数据
PoseGraph2D::GetTrajectoryStates() //获取所有轨迹状态

总的来说,上面这这些函数都是通过 PoseGraph2D:: data_.trajectories_state 获取轨迹状态的,另外 PoseGraph2D::DeleteTrajectoriesIfNeeded() 函数 在 PoseGraph2D::HandleWorkQueue() 中被调用,也就是前端数据到来时都会进行一次轨迹的删除判断,外部通过 PoseGraph2D::DeleteTrajectory() 函数如下代码:

    data_.trajectories_state.at(trajectory_id).deletion_state =InternalTrajectoryState::DeletionState::WAIT_FOR_DELETION;

把轨迹设置为等待删除,不用多说,被 PoseGraph2D::DeleteTrajectoriesIfNeeded() 检测到后就会被标记为删除。

注意 \color{red} 注意 注意 你没有看错,是标记为删除,仅仅是标记而已,实际上并没有真的删除轨迹以及相关数据。并且貌似 PoseGraph3D::TrimmingHandle::SetTrajectoryState() 这个函数还能把轨迹的状态恢复到正常,这个据具体再做细节分析了。

另外,轨迹的完成最终肯定要调用到 PoseGraph2D::FinishTrajectory() 其是如何传递的呢?代码如下:

//Node::FinishTrajectoryUnderLock() 
Node::HandleFinishTrajectory()
	Node::FinishTrajectoryUnderLock()
	 	MapBuilderBridge::FinishTrajectory()
	 		MapBuilder->FinishTrajectory()
	 			PoseGraph::FinishTrajectory()
	 				PoseGraph2D::FinishTrajectory()

这样轨迹就被标记为完成了。文件 node_main.cc 中的 Run() 函数 ::ros::spin() 后面会调用 FinishAllTrajectories 也就是Node::FinishAllTrajectories() ,其会遍历所有轨迹,判断轨迹是否活跃,如果处于活跃状态则也会调用 Node::FinishTrajectoryUnderLock() ,所以上面调用流程中 Node::FinishTrajectoryUnderLock() 与 Node::HandleFinishTrajectory() 是并列的关系。

四、 PoseGraph2D::RunFinalOptimization()

node_main.cc 中的 Run() 函数 ::ros::spin() 后,接着 node.FinishAllTrajectories(); 又调用了 node.RunFinalOptimization(),从命名可以知道,该函数是执行最后一次优化,最终调用到的函数为:

map_builder_bridge_.map_builder_->pose_graph()->RunFinalOptimization()

也就是 PoseGraph2D::RunFinalOptimization() 这个函数:

// 执行最后一次的优化, 等待所有的计算任务结束
void PoseGraph2D::RunFinalOptimization() {
  {
    AddWorkItem([this]() LOCKS_EXCLUDED(mutex_) {
      absl::MutexLock locker(&mutex_);
      // 设置更多的最大迭代次数
      optimization_problem_->SetMaxNumIterations(
          options_.max_num_final_iterations());
      // 执行一次优化
      return WorkItem::Result::kRunOptimization;
    });
    AddWorkItem([this]() LOCKS_EXCLUDED(mutex_) {
      absl::MutexLock locker(&mutex_);
      // 再设置回去
      optimization_problem_->SetMaxNumIterations(
          options_.optimization_problem_options()
              .ceres_solver_options()
              .max_num_iterations());
      // 结束了不用执行优化
      return WorkItem::Result::kDoNotRunOptimization;
    });
  }
  WaitForAllComputations();
}

其代码还是比较简单的,就是重新设置了后端问题优化中 ceres 最大的迭代次数然后加到工作队列中去,不过需要注意,紧接着又添加了一个任务,其把参数复原了。也就是说,设置所有轨迹为完成状态时,将不会往轨迹中添加数据,所以该函数添加的两个任务就是任务队列中排到最后的任务。最后再调用了 PoseGraph2D::WaitForAllComputations() 函数,等待所有任务计算完成:

// 等待所有的计算任务执行完成
void PoseGraph2D::WaitForAllComputations() {
  int num_trajectory_nodes;
  {
    absl::MutexLock locker(&mutex_);
    num_trajectory_nodes = data_.num_trajectory_nodes;
  }

  const int num_finished_nodes_at_start =
      constraint_builder_.GetNumFinishedNodes();

  // 报告节点计算的进度
  auto report_progress = [this, num_trajectory_nodes,
                          num_finished_nodes_at_start]() {
    // Log progress on nodes only when we are actually processing nodes.
    if (num_trajectory_nodes != num_finished_nodes_at_start) {
      std::ostringstream progress_info;
      progress_info << "Optimizing: " << std::fixed << std::setprecision(1)
                    << 100. *
                           (constraint_builder_.GetNumFinishedNodes() -
                            num_finished_nodes_at_start) /
                           (num_trajectory_nodes - num_finished_nodes_at_start)
                    << "%...";
      std::cout << "\r\x1b[K" << progress_info.str() << std::flush;
    }
  };

  // First wait for the work queue to drain so that it's safe to schedule
  // a WhenDone() callback.
  {
    const auto predicate = [this]()
                               EXCLUSIVE_LOCKS_REQUIRED(work_queue_mutex_) {
                                 return work_queue_ == nullptr;
                               };
    absl::MutexLock locker(&work_queue_mutex_);
    // 等待工作队列为空
    while (!work_queue_mutex_.AwaitWithTimeout(
        absl::Condition(&predicate),
        absl::FromChrono(common::FromSeconds(1.)))) { // 1秒打印一次进度
      report_progress();
    }
  }

  // Now wait for any pending constraint computations to finish.
  // 现在等待任何挂起的约束计算完成
  absl::MutexLock locker(&mutex_);
  bool notification = false;
  constraint_builder_.WhenDone(
      [this,
       &notification](const constraints::ConstraintBuilder2D::Result& result)
          LOCKS_EXCLUDED(mutex_) {
            absl::MutexLock locker(&mutex_);
            // 保存新计算的约束
            data_.constraints.insert(data_.constraints.end(), result.begin(),
                                     result.end());
            notification = true;
          });

  const auto predicate = [&notification]() EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
    return notification;
  };

  // 等待直到notification为true
  while (!mutex_.AwaitWithTimeout(absl::Condition(&predicate),
                                  absl::FromChrono(common::FromSeconds(1.)))) {
    report_progress();
  }
  CHECK_EQ(constraint_builder_.GetNumFinishedNodes(), num_trajectory_nodes);
  std::cout << "\r\x1b[KOptimizing: Done.     " << std::endl;
}

( 1 ) : \color{blue}(1): (1): 首先要注意到的是,该函数存在两个循环,第一个循环退出条件是队列为空,且会以1秒的间隔打印目前约束约束计算的进度,num_trajectory_nodes - num_finished_nodes_at_start 表示距离上一次优化完成,目前完成节点约束计算的数量,num_trajectory_nodes - num_finished_nodes_at_start 表示距离上一次优化完成,目前添加了多少个节点到队列中,他们的比值就是计算约束的进度,直到队列为空,才停止打印。

( 2 ) : \color{blue}(2): (2): 值得注意的是,队列为空,只能表示子图内的约束计算完成了,不能代表子图间约束也完成了,因为子图间约束是在处理 ConstraintBuilder2D 中完成计算的,其被直接分配给线程池,而非 PoseGraph2D 的工作队列。且是一定间隔节点的频率添加子图间约束,该部分在PoseGraph2D::ComputeConstraint()中有体现,如 global_localization_samplers_[node_id.trajectory_id]->Pulse() 就是对全局约束采样频率的控制。

( 3 ) : \color{blue}(3): (3): 那么不多说,需要等待所有约束计算以及相应的优化完成。回顾一下前面的代码 PoseGraph2D::DrainWorkQueue(),单计算约束的节点累计到一定数量时,则会执行如下函数:

  constraint_builder_.WhenDone(
      [this](const constraints::ConstraintBuilder2D::Result& result) {
        HandleWorkQueue(result);
      });

通过 HandleWorkQueue() 取调用 RunOptimization(),PoseGraph2D::optimization_problem_ 之中,的约束进以及计前端位姿、里程计odom数据、landmark数据、等数据进行与 global 系相关位姿的优化。但是,这里却没有必要,必要了,因为最后一次优化,我们希望使用前面
PoseGraph2D::RunFinalOptimization() 函数添加到任务队列中中的配置(迭代次数更多)进行优化。所以原本调用 HandleWorkQueue()→RunOptimization()优化的方式要取消,所以所以把回调函数修改成如下:

  constraint_builder_.WhenDone(
      [this,
       &notification](const constraints::ConstraintBuilder2D::Result& result)
          LOCKS_EXCLUDED(mutex_) {
            absl::MutexLock locker(&mutex_);
            // 保存新计算的约束
            data_.constraints.insert(data_.constraints.end(), result.begin(),
                                     result.end());
            notification = true;
          });

其就是把最后一个计算出来的约束,保存到 data_.constraint 之中,且把 notification 设置为 true。

( 4 ) : \color{blue}(4): (4): 其设置好新的 constraint_builder_.WhenDone 之后,就进入到第二个循环进行等待了,等待 notification 被设置为 true,才退出,也就是新的 constraint_builder_.WhenDone 被执行的时候。

( 5 ) : \color{blue}(5): (5): PoseGraph2D::RunFinalOptimization() 函数再添加到队列的第一个任务返回值为 WorkItem::Result::kRunOptimization,也就是说该函数被 PoseGraph2D::DrainWorkQueue() 处理之后,会调用constraint_builder_.WhenDone,而此时其已经被设置为新的代码形式。会把 notification 被设置为 true。且新形式不会再调用 PoseGraph2D::HandleWorkQueue() 进入循环,线程结束。PoseGraph2D::WaitForAllComputations() 感应到 notification 被设置为 true 之后,循环结束。检查完成约束计算的节点数 constraint_builder_.GetNumFinishedNodes() 是否与总节点 num_trajectory_nodes 相等,然后输出告知优化完成

注意 : \color{blue}注意: 注意: 调用 PoseGraph2D::RunFinalOptimization() 与 PoseGraph2D::HandleWorkQueue() 的并非同一个线程,PoseGraph2D::RunFinalOptimization() 来自于执行 node_main.cc 的主线程,其添加好两个任务(修改优化参数、复原修改参数) 之后,然后调用 WaitForAllComputations() 函数等待队列为空,之后重设 constraint_builder_.WhenDone() 函数,该函数需要工作队列任务被执行之后,返回 WorkItem::Result::kRunOptimization 才会被执行,RunFinalOptimization() 中有设置,所以其会执行,但是执行的时被重设之后的。

五、 总结

通过该篇博客,首先了解到轨迹是如何结束的,知道有两种方式,通过服务或者 ctrl + c 结束进程时,都可完成轨迹的结束,轨迹结束最总都是调用 PoseGraph2D::FinishTrajectory() 函数变换轨迹的状态。如果使用 ctrl + c 结束,其还会执行最后一次优化,即最总调用到 PoseGraph2D::RunFinalOptimization() 函数。除了停止轨迹的服务,源码中还创建了很多服务,在 Node::Node() 这个构造函数中可以看到如下代码:

  // Step: 2 声明发布对应名字的ROS服务, 并将服务的发布器放入到vector容器中
  service_servers_.push_back(node_handle_.advertiseService(
      kSubmapQueryServiceName, &Node::HandleSubmapQuery, this));
  service_servers_.push_back(node_handle_.advertiseService(
      kTrajectoryQueryServiceName, &Node::HandleTrajectoryQuery, this));
  service_servers_.push_back(node_handle_.advertiseService(
      kStartTrajectoryServiceName, &Node::HandleStartTrajectory, this));
  service_servers_.push_back(node_handle_.advertiseService(
      kFinishTrajectoryServiceName, &Node::HandleFinishTrajectory, this));
  service_servers_.push_back(node_handle_.advertiseService(
      kWriteStateServiceName, &Node::HandleWriteState, this));
  service_servers_.push_back(node_handle_.advertiseService(
      kGetTrajectoryStatesServiceName, &Node::HandleGetTrajectoryStates, this));
  service_servers_.push_back(node_handle_.advertiseService(
      kReadMetricsServiceName, &Node::HandleReadMetrics, this));

如子图,轨迹的查询,开始一条新的轨迹,获取轨迹等。另外还可以看到 Node::HandleWriteState 这个服务,服务名称为 write_state,其作用就是把整个 cartographer 系统的状态以 proto 流文件的形式保存下来。下一篇博客,我们就来分析一下。

42页Claude 3技术报告解读(Opus, Sonnet, Haiku) 在Claude 3模型中,增加了一个额外的原则到Claude的宪法中,以鼓励尊重残疾人权利,这一原则源自对集体宪法AI的研究。Claude 3模型的训练基于专有的混合数据集,包括截至2023年8月互联网上公开可用的信息,以及第三方提供的非公开数据、数据标注服务和付费承包商提供的数据,还有内部生成的数据。这些初始响应通常包含有害和有毒的内容。Claude 3模型家族在推理、编码和问答任务上展现出卓越的性能,特别是在行业标准基准测试中取得了显著的提升,证明了其在处理复杂问题和提供准确答案方面的能力。 阅读详情

相关推荐

从零到一:DETR模型在自定义数据集上的实战部署与调优

本文详细介绍了DETR模型在自定义数据集上的实战部署与调优过程,包括环境准备、数据转换、模型配置、训练技巧及问题排查。通过具体代码示例和实用建议,帮助开发者高效完成从零到一的DETR模型部署,特别适合目标检测领域的实践应用。

weixin_42524100的博客 466

cartographer_ros node (三):结束轨迹

上一次我们详细讲述了node_main中对应的开始轨迹的函数StartTrajectoryWithDefaultTopics,这次我们主要讲解在结束SLAM之后调用的node类中的两个函数FinishAllTrajectories和RunFinalOptimization()。 首先是FinishAllTrajectories,这个函数用于结束所有处于活动状态的轨迹 // 结束所有处于活动状态的轨迹 void Node::FinishAllTrajectories() { absl::MutexLock

weixin_39061796的博客 586

Qt Design Studio 入门指南:从零开始打造炫酷UI(详细+实用+轻松上手)

本文是Qt Design Studio的详细入门指南,旨在帮助UI设计新手从零开始轻松打造炫酷界面。文章系统介绍了软件的核心概念、安装步骤、主界面解析,并通过创建一个完整的登录界面实例,手把手教学如何拖拽组件、设置属性、添加交互状态与动画。同时,分享了创建自定义组件、管理资源以及提升效率的实用技巧与常见问题解决方案,让读者能够快速上手并应用于实际项目开发。

devops8pract的博客 594

cartographer 源码解析(一)

cartographer算法是google大佬2016年写的开源SLAM算法,其主要是以2D定位为主。 我们首先从cartographer_ros这个源码开始对其进行

To be a better man 6407

uniapp监听扫码枪键盘事件|无输入框式监听

一般的扫码枪通过USB或蓝牙连接手机或电脑,充当的是一个外接设备。当扫码后,扫码枪会自动识别内容,然后向连接的电脑或手机发送键盘事件keydown或keyup。

tcy9099的专栏 9756

LTspice第三方SPICE模型集成全流程指南

SPICE模型是电子电路仿真的核心基础,它通过数学方程描述半导体器件的非线性、温度依赖与寄生特性,决定仿真结果是否具备工程可信度。其技术价值在于 bridging 理论参数与实测行为,显著提升电源、电机驱动及逻辑电路设计的一次成功率。典型应用场景包括IGBT开关损耗分析、LDO瞬态响应验证、CMOS逻辑门传播延迟评估等。而LTspice作为轻量级工业级工具,依赖用户主动集成原厂提供的.subckt或.model文本模型——这正是‘LTspice导入SPICE模型’和‘74HC14 SPICE模型’等高频搜索

weixin_33868027的博客 319

cartographer的localization模式设置初始位姿

    cartographer的localization模式机器人的初始位姿默认为建图时的起点位姿。理论上机器人运动一段时间后通过新局部子图与全局地图相匹配能获取较为理想的位姿,故无需考虑机器人启动位姿。如果能知道机器人启动时的初始位姿,对机器人的导航还是有所帮助。故在此还是提供一个设置初始位姿的方法。    主要调用了github上作者们提供的initial_pose的接口。个人的理解可能不够...

cabinx的博客 1万+

FreeSWITCH编译安装详细文档

本文档详细介绍了在Ubuntu 22.04系统上从源码编译安装FreeSWITCH的完整流程。主要内容包括:1)系统环境准备和依赖库安装;2)关键依赖库spandsp和sofia-sip的编译安装;3)FreeSWITCH源码的特定版本(v1.6.0)编译配置,包括禁用SignalWire模块的配置方法;4)系统服务配置,包括创建专用用户、设置权限以及配置systemd服务文件。文档特别提供了版本控制说明,确保后期能切换到相同的版本环境,并附有详细的命令操作步骤和注意事项。

唯有代码让我痴狂 1375

cartographer代码解读2_cartographer_ros部分

0 debug 编译 cartographer 版本是在1.0以后,本人fork的是2021.0.25的版本,commit id:0d2bc2ca5b834ddd03504454d0a43b9f67c20455. 编译方式 catkin_make_isolated --install --use-ninja -DFORCE_DEBUG_BUILD=True 1 cartographer_node总结: cartographer启动以后,做了如下的工作: 注册并发布了5个Topic, 并为5个Topic分

DoctorChen618的专栏 1896

亚马逊广告接口 amazon advertising

亚马逊广告接口官方说明:https://advertising.amazon.com/API/docs/en-us/setting-up/account-setup 一:注册aws开发者账号 注册地址:https://developer.amazon.com 二:填写注册资料 三:进入控制台,生成安全配置文件 进入 Login with Amazon 菜单: 创建配置文件: 四:申请广告接入权限 申请地址:https://advertising.amazon.com/zh-cn/about-api

lzy66666的博客 4788

卡方分布的前世今生:一个统计概念的演化史

本文追溯了卡方分布从19世纪末的理论雏形到现代统计推断核心工具的发展历程。从Karl Pearson的数学奠基到Ronald Fisher的理论完善,卡方分布在医学研究、社会科学和机器学习等领域展现出广泛应用。文章通过代码示例和性质分析,揭示了这一统计概念如何持续推动数据科学创新。

weixin_29251567的博客 397

Cartographer源码篇:源码分析(1)

本文主要对cartographer_ros的文件结构、节点、代码、流程进行了简单的梳理,理解cartographer_ros是cartographer在ROS平台的封装。

slamml 2762

企业级大模型落地:私有化部署的安全合规全流程实战指南

摘要:本文针对企业在大模型私有化部署中面临的数据泄露、合规风险及系统稳定性难题,提出一套覆盖数据安全、模型合规、审计追踪与灾备方案的全流程解决方案。通过双加密管道(国密SM4传输加密+AES-GCM存储加密)、SGX可信执行环境等技术,实现数据全生命周期保护;结合等保2.0三级要求与《生成式AI服务管理暂行办法》,提供合规性实施细则;并给出本地GPU集群、混合云、边缘推理盒子三种企业级部署方案及成本模型。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 934

Cartographer学习之node类

node类简要介绍

m0_55879913的博客 472

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

(02)Cartographer源码无死角解析-(66) 2D后端优化→PrecomputationGridStack2D、SlidingWindowMaximum -构建多分辨率地图

疑问1疑问1global_submap_poses 等价于 PoseGraph2D::data_.global_submap_poses_2d 是何时进行优化的。// 生成一个将初始化匹配器的任务, 初始化时会计算多分辨率地图, 比较耗时 scan_matcher_task -> SetWorkItem([ & submap_scan_matcher , & scan_matcher_options ]() {

江南才尽江南山,年少无知年少狂! 1693

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

cartographer-ros阅读梳理(五)后端部分-关于pose_graph节点的建立与维护

对pose_graph的构成和功能、约束器的建立与维护进行分析

qq_46480449的博客 1238

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

cartographer 源码解析 (三)

今天讲一下数据格式转化具体的过程,首先以激光数据为例子,看一下在node.cc里面的激光的回调函数。 node.cc void Node::HandleLaserScanMessage(const int trajectory_id, const std::string& sensor_id, const sensor_msgs::LaserScan::ConstP

To be a better man 1961

Cartographer学习记录:cartographer源码3D SLAM部分(三)

Cartographer 3D源码阅读之上层cartographer_ros介绍

smartfoolish的博客 863

简写工具类

系列文章目录 提示:函数式编程思想 文章目录系列文章目录前言一、简写编程写法?总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。 提示:以下是本篇文章正文内容,下面案例可供参考 一、简写编程写法? let res = 1; if(res) console.log(1111) // 1111 res && console.log(333) // 333 总

hammer1010的博客 415

cartographer源码解析(七)轨迹优化

描述 主要分析node_main.cc中的Run()函数中的RunFinalOptimization() node.RunFinalOptimization(); RunFinalOptimization()的基本逻辑 第一层:node.cc RunFinalOptimization()函数定义在node.cc void Node::RunFinalOptimization() { { for (const auto& entry : map_builder_bridge_.GetTr

weixin_42156097的博客 893

cartographer 源码解析(六)

相关链接: cartographer 源码解析(一) cartographer 源码解析(二) cartographer 源码解析(三) cartographer 源码解析(四) cartographer 源码解析(五)

To be a better man 2546

Cartographer源码解析——2D栅格地图构建

到目前为止,对于点云数据的预处理过程已经介绍完毕,如:点云数据多传感器时间同步、运动畸变校正、重力校正、体素滤波等。做完这一系列的预备工作之后,实际上呢,就可以进行点云的扫描匹配了。在讲解扫描匹配之前,先来看看 Cartographer 2D 的栅格地图,其不像3D点云地图有很多成熟的库可以调用,具有统一的标准。大多数 2D Slam 的栅格地图都是需要自己编写代码进行构建的。下面就来看看 Cartographer 中时如何构建的。

m0_67976789的博客 5219

cartographer源码解析(二)node_main.cc文件详解

cartographer学习笔记(二)这一篇主要分析node_main.cc的代码。

qq_29320587的博客 386

cartographer 源码解析 (五)

相关链接: cartographer 源码解析(一) cartographer 源码解析(二) cartographer 源码解析(三) cartographer 源码解析(四) cartographer 源码解析(五) 因为第四节用文字表达起来有些难以直观的去理解,所以我录制了讲解的视频:https://www.bilibili.com/video/BV1go4y1D792 本章节主要讲的内容是对外推器的数据进行激光矫正。 ...

To be a better man 1899

Cartographer源码简读

Cartographer源码简读

xiner0114的博客 2831

【Cartographer源码解析】定位模式初始位姿设定原理与实战优化

本文深入解析了Cartographer定位模式中初始位姿设定的原理与优化方法。通过源码分析,揭示了默认从map坐标系原点开始搜索的性能瓶颈,并提供了修改初始位姿的实战方案。优化后,重定位时间从8分钟缩短至27秒,显著提升了大场景下的定位效率。

weixin_29775479的博客 231
上一篇: (02)Cartographer源码无死角解析-(81) ROS栅格地图→服务接收子图、cairo图像绘详解、OccupancyGrid地图发布
下一篇: (02)Cartographer源码无死角解析-(83) SerializeStateToFile序列化保存、ProtoStreamWriter分析、PoseGraph::ToProto()函数粗解
江南才尽,年少无知!
江南才尽,年少无知! 领域专家: 人工智能技术领域 领域专家: 人工智能技术领域
博客等级 码龄8年 4万+粉丝 519原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

江南才尽,年少无知!

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

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

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

打赏作者

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

抵扣说明:

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

余额充值
⌂ 换网址