puai_wj_2021/system/system_executor.cpp

//
// Created by huli on 2020/7/2.
//

#include "system_executor.h"
#include "../message/measure_message.pb.h"
#include "../laser/laser_manager.h"
#include "../locate/locate_manager.h"
#include "../system/system_communication.h"
#include "../wanji_lidar/wanji_manager.h"
#include "../tool/common_data.h"
#include "../locate/locate_manager.h"

System_executor::System_executor()
{

}

System_executor::~System_executor()
{
	system_executor_uninit();
}

//初始化
Error_manager System_executor::system_executor_init(int threads_size, int terminal_id)
{
	m_thread_pool.thread_pool_init(threads_size);
	m_system_executor_status = SYSTEM_EXECUTOR_READY;
	m_terminal_id = terminal_id;
	return Error_code::SUCCESS;
}

//反初始化
Error_manager System_executor::system_executor_uninit()
{
	m_thread_pool.thread_pool_uninit();
	m_system_executor_status = SYSTEM_EXECUTOR_UNKNOW;
	return Error_code::SUCCESS;
}

//检查消息是否有效, 主要检查消息类型和接受者, 判断这条消息是不是给我的.
Error_manager System_executor::check_msg(Communication_message* p_msg)
{
	if ( p_msg == NULL )
	{
		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
							 "  POINTER IS NULL ");
	}

	//检查消息类型
	switch ( p_msg->get_message_type() )
	{
		case Communication_message::Message_type::eLocate_request_msg:
		{
			//检查接受人
			if ( p_msg->get_receiver() == Communication_message::Communicator::eMeasurer )
			{
				message::Measure_request_msg t_measure_request_msg;
				//针对消息类型, 对消息进行二次解析
				if (t_measure_request_msg.ParseFromString(p_msg->get_message_buf()))
				{
					//检查终端id
					if ( t_measure_request_msg.terminal_id() == m_terminal_id )
					{
						return Error_code::SUCCESS;
					}
				}
			}
			break;
		}
		case Communication_message::Message_type::eLocate_sift_response_msg:
		{
			//检查接受人
			if ( p_msg->get_receiver() == Communication_message::Communicator::eMeasurer )
			{
				message::Locate_sift_response_msg t_locate_sift_response_msg;
				//针对消息类型, 对消息进行二次解析
				if (t_locate_sift_response_msg.ParseFromString(p_msg->get_message_buf()))
				{
					//检查终端id
					if ( t_locate_sift_response_msg.terminal_id() == m_terminal_id )
					{
						return Error_code::SUCCESS;
					}
				}
			}
			break;
		}
		default :
			;
			break;
	}


	//无效的消息,
	return Error_manager(Error_code::INVALID_MESSAGE, Error_level::NEGLIGIBLE_ERROR,
						 " INVALID_MESSAGE error ");
}

//检查执行者的状态, 判断能否处理这条消息,
Error_manager System_executor::check_executer(Communication_message* p_msg)
{
	//huli DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD  记得删除
	return Error_code::SUCCESS;
	if ( p_msg == NULL )
	{
		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
							 "  POINTER IS NULL ");
	}

	Error_manager t_error;
	//通过 p_msg->get_message_type() 和 p_msg->get_receiver() 找到处理模块的实例对象, 查询执行人是否可以处理这条消息
	switch ( p_msg->get_message_type() )
	{
		case Communication_message::Message_type::eLocate_request_msg:
		{
			Error_manager t_laser_result = Laser_manager::get_instance_references().check_status();
			Error_manager t_executor_result = System_executor::get_instance_references().check_status();
			Error_manager t_locate_result = Locate_manager::get_instance_references().check_status();

			if (t_laser_result == SUCCESS
				&& t_executor_result == SUCCESS
				&& t_locate_result == SUCCESS)
			{
				return Error_code::SUCCESS;
			}
			else
			{
				//整合所有的错误码
				t_error.compare_and_cover_error(t_laser_result);
				t_error.compare_and_cover_error(t_executor_result);
				t_error.compare_and_cover_error(t_locate_result);
				if (t_error.get_error_level() == NEGLIGIBLE_ERROR)//一级故障,轻微故障,
				{
					std::cout << "executer_is_busy , " << std::endl;
					//返回繁忙之后, 通信模块1秒后再次调用check
					return Error_code::COMMUNICATION_EXCUTER_IS_BUSY;
				}
				else//返回二级故障,可以封装一条答复信息, 返回错误码
				{
					message::Measure_request_msg t_measure_request_msg;
					//针对消息类型, 对消息进行二次解析
					if (t_measure_request_msg.ParseFromString(p_msg->get_message_buf()))
					{
						//创建一条答复消息
						message::Measure_response_msg t_measure_response_msg;
						t_measure_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_response_msg);
						t_measure_response_msg.mutable_base_info()->set_timeout_ms(5000);
						t_measure_response_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
						t_measure_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);

						t_measure_response_msg.set_command_key(t_measure_request_msg.command_key());
						t_measure_response_msg.set_terminal_id(t_measure_request_msg.terminal_id());
						t_measure_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
						t_measure_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
						t_measure_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description());

						string t_msg = t_measure_response_msg.SerializeAsString();
						System_communication::get_instance_references().encapsulate_msg(t_msg);
						LOG(INFO) << " System_executor::check_executer executer status error "<< this;
						return t_error;
					}
					else
					{
						LOG(INFO) << " System_executor::check_executer second PARSE_ERROR "<< this;
						return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
											 " message::Measure_request_msg  ParseFromString error ");
					}
				}
			}
			break;
		}
		case Communication_message::Message_type::eLocate_sift_response_msg:
		{
			//不用检查状态, 直接返回成功
			return Error_code::SUCCESS;
			break;
		}
		default :
			;
			break;
	}


	return t_error;
}


//处理消息的执行函数
Error_manager System_executor::execute_msg(Communication_message* p_msg)
{
	if ( p_msg == NULL )
	{
		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
							 "  POINTER IS NULL ");
	}
	switch ( p_msg->get_message_type() )
	{
		case Communication_message::eLocate_request_msg:
		{
			message::Measure_request_msg t_measure_request_msg;
			//针对消息类型, 对消息进行二次解析
			if (t_measure_request_msg.ParseFromString(p_msg->get_message_buf()))
			{
				//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
				m_thread_pool.enqueue(&System_executor::execute_for_measure, this,
									  t_measure_request_msg.command_key(), t_measure_request_msg.terminal_id(),
									  p_msg->get_receive_time());
			}
			else
			{
				return Error_manager(Error_code::SYSTEM_EXECUTOR_PARSE_ERROR, Error_level::MINOR_ERROR,
									 " message::Measure_request_msg  ParseFromString error ");
			}
			break;
		}
		case Communication_message::eLocate_sift_request_msg:
		{
			//往线程池添加执行任务, 之后会唤醒一个线程去执行他.
			m_thread_pool.enqueue(&System_executor::execute_for_predict, this,
								  p_msg->get_message_buf());
			break;
		}
		default:
		{

		}
	}


	return Error_code::SUCCESS;
}

//检查状态
Error_manager System_executor::check_status()
{
	if ( m_system_executor_status == SYSTEM_EXECUTOR_READY )
	{
		if ( m_thread_pool.thread_is_full_load() == false )
		{
			return Error_code::SUCCESS;
		}
		else
		{
			return Error_manager(Error_code::SYSTEM_EXECUTOR_STATUS_BUSY, Error_level::NEGLIGIBLE_ERROR,
								 " System_executor::check_status error ");
		}
	}
	else
	{
		return Error_manager(Error_code::SYSTEM_EXECUTOR_STATUS_ERROR, Error_level::MINOR_ERROR,
							 " System_executor::check_status error ");
	}
}

//定时发送状态信息
Error_manager System_executor::encapsulate_send_status()
{
	Error_manager t_error;
	//创建一条状态消息
	message::Measure_status_msg t_measure_status_msg;
	t_measure_status_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_status_msg);
	t_measure_status_msg.mutable_base_info()->set_timeout_ms(5000);
	t_measure_status_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
	t_measure_status_msg.mutable_base_info()->set_receiver(message::Communicator::eEmpty);

	t_measure_status_msg.set_terminal_id(m_terminal_id);

	//大疆livox
	Laser_manager::Laser_manager_status t_laser_manager_status = Laser_manager::get_instance_references().get_laser_manager_status();
	t_measure_status_msg.set_laser_manager_status((message::Laser_manager_status)t_laser_manager_status);

	std::vector<Laser_base*> & t_laser_vector = Laser_manager::get_instance_references().get_laser_vector();
	for (auto iter = t_laser_vector.begin(); iter != t_laser_vector.end(); ++iter)
	{
		Laser_statu t_laser_statu = (*iter)->get_laser_statu();
		t_measure_status_msg.add_laser_statu_vector((message::Laser_statu)t_laser_statu);
	}

	Locate_manager::Locate_manager_status t_locate_manager_status = Locate_manager::get_instance_references().get_locate_manager_status();
	t_measure_status_msg.set_locate_manager_status((message::Locate_manager_status)t_locate_manager_status);

	//万集716
	Wanji_manager::Wanji_manager_status t_wanji_manager_status = Wanji_manager::get_instance_references().get_status();
	t_measure_status_msg.set_wanji_manager_status((message::Wanji_manager_status)t_wanji_manager_status);

	std::map<int, Wanji_lidar_device*> & t_wanji_lidar_device_map = Wanji_manager::get_instance_references().get_wanji_lidar_device_map();
	for (auto iter = t_wanji_lidar_device_map.begin(); iter != t_wanji_lidar_device_map.end(); ++iter)
	{
		Wanji_lidar_device::Wanji_lidar_device_status t_wanji_lidar_device_status = (*iter).second->get_status();
		t_measure_status_msg.add_wanji_lidar_device_status((message::Wanji_lidar_device_status)t_wanji_lidar_device_status);
	}

	std::map<int, Region_worker*> & t_region_worker_map = Wanji_manager::get_instance_references().get_region_worker_map();
	for (auto iter = t_region_worker_map.begin(); iter != t_region_worker_map.end(); ++iter)
	{
		Region_worker::Region_worker_status t_region_worker_status = (*iter).second->get_status();
		t_measure_status_msg.add_region_worker_status((message::Region_worker_status)t_region_worker_status);

		//万集雷达的自动定位信息
		Common_data::Car_wheel_information	t_car_wheel_information;
		t_error = (*iter).second->get_last_wheel_information(&t_car_wheel_information, std::chrono::system_clock::now());

		//无论定位结果如何, 都要填充数据, 即使全部写0, 必须保证通信格式正确.
		message::Locate_information* tp_locate_information = t_measure_status_msg.add_locate_information_realtime();
		tp_locate_information->set_locate_x(t_car_wheel_information.center_x);
		tp_locate_information->set_locate_y(t_car_wheel_information.center_y);
		tp_locate_information->set_locate_angle(t_car_wheel_information.car_angle);
		tp_locate_information->set_locate_length(0);
		tp_locate_information->set_locate_width(0);
		tp_locate_information->set_locate_height(0);
		tp_locate_information->set_locate_wheel_base(t_car_wheel_information.wheel_base);
		tp_locate_information->set_locate_wheel_width(t_car_wheel_information.wheel_width);
		tp_locate_information->set_locate_front_theta(t_car_wheel_information.front_theta);
		tp_locate_information->set_locate_correct(t_car_wheel_information.correctness);
	}


	t_measure_status_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
	t_measure_status_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
	t_measure_status_msg.mutable_error_manager()->set_error_description(t_error.get_error_description(), t_error.get_description_length());

	std::cout << " huli test :::: " << " t_measure_status_msg.DebugString() = "  << std::endl;
	std::cout << t_measure_status_msg.DebugString() << std::endl;


	string t_msg = t_measure_status_msg.SerializeAsString();
	System_communication::get_instance_references().encapsulate_msg(t_msg);

	return Error_code::SUCCESS;
}

//判断是否为待机，如果已经准备好，则可以执行任务。
bool System_executor::is_ready()
{
	if ( m_system_executor_status == SYSTEM_EXECUTOR_READY && m_thread_pool.thread_is_full_load() == false )
	{
		return true;
	}
	else
	{
		return false;
	}
}

System_executor::System_executor_status System_executor::get_system_executor_status()
{
	return m_system_executor_status;
}

int System_executor::get_terminal_id()
{
	return m_terminal_id;
}



//雷达感测定位 的处理函数
//input::command_id, 消息指令id, 由主控制系统生成的唯一码
//input::command_id, 终端id, 对应具体的某个车位
//return::void, 没有返回, 执行结果直接生成一条答复消息, 然后通过通信返回
void System_executor::execute_for_measure(std::string command_info, int terminal_id,std::chrono::system_clock::time_point receive_time)
{
	Error_manager t_error;
	Error_manager t_result;
	LOG(INFO) << " System_executor::execute_for_measure run "<< this;

	//第一步, 创建点云缓存, 和 指定雷达,目前就一个
	std::map<int,pcl::PointCloud<pcl::PointXYZ>::Ptr>		point_cloud_map;
	std::mutex cloud_lock;
	std::vector<int> select_laser_id_vector;
	select_laser_id_vector.push_back(0);
	select_laser_id_vector.push_back(1);
	select_laser_id_vector.push_back(2);
	select_laser_id_vector.push_back(3);
	//第二步, 按照时间生成中间文件的保存路径
	time_t nowTime;
	nowTime = time(NULL);
	struct tm* sysTime = localtime(&nowTime);
	char t_save_path[256] = { 0 };
	sprintf(t_save_path, "../data/%04d%02d%02d_%02d%02d%02d",
			sysTime->tm_year + 1900, sysTime->tm_mon + 1, sysTime->tm_mday, sysTime->tm_hour, sysTime->tm_min, sysTime->tm_sec);


	//第三步, 创建雷达管理模块的任务单, 并发送到 laser_manager
	Laser_manager_task  laser_manager_task ;
	laser_manager_task.task_init(TASK_CREATED,"",NULL,std::chrono::milliseconds(15000),
								  true,t_save_path,&cloud_lock,&point_cloud_map,false,
								  1000,false,select_laser_id_vector	);
	t_error = Task_command_manager::get_instance_references().execute_task(&laser_manager_task);
//			tp_laser_manager->execute_task(laser_manager_task);


	//第四步, 等待任务单完成
	if ( t_error != Error_code::SUCCESS )
	{
		LOG(INFO) << " Laser_manager  execute_task   error "<< this;
	}
	else
	{
		//判断任务是否结束, 阻塞 等待, 直到任务完成或者超时
		while ( laser_manager_task.is_task_end() == false)
		{
			if ( laser_manager_task.is_over_time() )
			{
				//超时处理。取消任务。
				Laser_manager::get_instance_pointer()->cancel_task();
				laser_manager_task.set_task_statu(TASK_DEAD);
				t_error.error_manager_reset(Error_code::LASER_MANAGER_TASK_OVER_TIME, Error_level::MINOR_ERROR,
											" laser_manager_task is_over_time ");
				laser_manager_task.set_task_error_manager(t_error);
			}
			else
			{
				//继续等待
				std::this_thread::sleep_for(std::chrono::microseconds(1));
				std::this_thread::yield();
			}
		}

		//提取任务单 的错误码
		t_error = laser_manager_task.get_task_error_manager();
		if ( t_error != Error_code::SUCCESS )
		{
			LOG(INFO) << " laser_manager_task error :::::::"  << laser_manager_task.get_task_error_manager().to_string() << this;
		}
	}
	t_result.compare_and_cover_error(t_error);



	Locate_manager_task locate_manager_task ;
	Common_data::Car_measure_information t_car_information_by_livox;

	if ( t_error != Error_code::SUCCESS )
	{
	    LOG(INFO) << " laser_manager_task error "<< this;
	}
	else
	{
		//第五步, 创建定位模块的任务单, 并发送到 Locate_manager
		locate_manager_task.task_init(TASK_CREATED,"",NULL,std::chrono::milliseconds(15000),
									   true,t_save_path,&cloud_lock,&point_cloud_map, false	);
		t_error = Task_command_manager::get_instance_references().execute_task(&locate_manager_task);

		//第六步, 等待任务单完成
		if ( t_error != Error_code::SUCCESS )
		{
			LOG(INFO) << " Locate_manager  execute_task error "<< this;
		}
		else
		{
			//判断任务是否结束, 阻塞 等待, 直到任务完成或者超时
			while ( locate_manager_task.is_task_end() == false)
			{
				if ( locate_manager_task.is_over_time() )
				{
					//超时处理。取消任务。
					Locate_manager::get_instance_pointer()->cancel_task();
					locate_manager_task.set_task_statu(TASK_DEAD);
					t_error.error_manager_reset(Error_code::LOCATE_MANAGER_TASK_OVER_TIME, Error_level::MINOR_ERROR,
												" locate_manager_task is_over_time ");
					locate_manager_task.set_task_error_manager(t_error);
				}
				else
				{
					//继续等待
					std::this_thread::sleep_for(std::chrono::microseconds(1));
					std::this_thread::yield();
				}

			}
			//提取任务单 的错误码
			t_error = locate_manager_task.get_task_error_manager();
			if ( t_error == Error_code::SUCCESS )
			{
				t_car_information_by_livox.center_x = locate_manager_task.get_task_locate_information_ex()->locate_x;
				t_car_information_by_livox.center_y = locate_manager_task.get_task_locate_information_ex()->locate_y;
				t_car_information_by_livox.car_angle = locate_manager_task.get_task_locate_information_ex()->locate_angle;
				t_car_information_by_livox.car_length = locate_manager_task.get_task_locate_information_ex()->locate_length;
				t_car_information_by_livox.car_width = locate_manager_task.get_task_locate_information_ex()->locate_width;
				t_car_information_by_livox.car_height = locate_manager_task.get_task_locate_information_ex()->locate_height;
				t_car_information_by_livox.wheel_base = locate_manager_task.get_task_locate_information_ex()->locate_wheel_base;
				t_car_information_by_livox.wheel_width = locate_manager_task.get_task_locate_information_ex()->locate_wheel_width;
				t_car_information_by_livox.front_theta = 0;
				t_car_information_by_livox.correctness = true;
			}
			else
			{
			    LOG(INFO) << " locate_manager_task error :::::::"  << locate_manager_task.get_task_error_manager().to_string() << this;
			}
		}
	}
	t_result.compare_and_cover_error(t_error);


	//第7步, 创建万集管理模块的任务单, 并发送到 wanji_manager
	Wanji_manager_task  t_wanji_manager_task ;
	Common_data::Car_wheel_information	t_car_information_by_wanji;
	t_wanji_manager_task.task_init(TASK_CREATED,"",NULL,std::chrono::milliseconds(15000),
								   terminal_id, receive_time);
	t_error = Task_command_manager::get_instance_references().execute_task(&t_wanji_manager_task);


	//第8步, 等待任务单完成
	if ( t_error != Error_code::SUCCESS )
	{
		LOG(INFO) << " Wanji_manager  execute_task   error "<< this;
	}
	else
	{
		//判断任务是否结束, 阻塞 等待, 直到任务完成或者超时
		while ( t_wanji_manager_task.is_task_end() == false)
		{
			if ( t_wanji_manager_task.is_over_time() )
			{
				//超时处理。取消任务。
				Wanji_manager::get_instance_pointer()->cancel_task(&t_wanji_manager_task);
				t_error.error_manager_reset(Error_code::WJ_MANAGER_TASK_OVER_TIME, Error_level::MINOR_ERROR,
											" t_wanji_manager_task is_over_time ");
				t_wanji_manager_task.set_task_error_manager(t_error);
			}
			else
			{
				//继续等待
				std::this_thread::sleep_for(std::chrono::microseconds(1));
				std::this_thread::yield();
			}
		}

		//提取任务单 的错误码
		t_error = t_wanji_manager_task.get_task_error_manager();
		if ( t_error == Error_code::SUCCESS )
		{
			t_car_information_by_wanji = t_wanji_manager_task.get_car_wheel_information();
		}
		else
		{
		    LOG(INFO) << " wanji_manager_task error :::::::"  << t_wanji_manager_task.get_task_error_manager().to_string() << this;
		}
	}
	t_result.compare_and_cover_error(t_error);


	//measure 测量模块的最终结果
	Common_data::Car_measure_information	t_car_information_result;
	//第9步, 对比livox和万集的, 并且进行校验
	//都成功则选最优解, 返回成功
	//其中一个构成, 就返回一个数据, 并返回错误码, 降级为一级故障
	//都失败就直接返回错误码,
	if ( t_car_information_by_livox.correctness == true && t_car_information_by_wanji.correctness == true )
	{
		//2个都有效时, 进行对比
		float offset_x = fabs(t_car_information_by_livox.center_x - t_car_information_by_wanji.center_x);
		float offset_y = fabs(t_car_information_by_livox.center_y - t_car_information_by_wanji.center_y);
		float offset_angle = fabs(t_car_information_by_livox.car_angle - t_car_information_by_wanji.car_angle);
		float offset_wheel_width = fabs(t_car_information_by_livox.wheel_width - t_car_information_by_wanji.wheel_width);
		float offset_wheel_base = fabs(t_car_information_by_livox.wheel_base - t_car_information_by_wanji.wheel_base);
		if (offset_x > 100 || offset_y > 150 || offset_angle > 3 || offset_wheel_base > 550 || offset_wheel_width > 250) {
			LOG(WARNING) << "chekc failed. (offset x>100, y>150, angle>3, wheel_base>550, width>250): " << offset_x
						 << " " << offset_y << " " << offset_angle << " " << offset_wheel_base << " " << offset_wheel_width;
			t_error =  Error_manager(TERMINOR_CHECK_RESULTS_ERROR, MINOR_ERROR, "check results failed ");
			t_result.compare_and_cover_error(t_error);
		}
		else
		{
			///根据sigmod函数计算角度权重
			double angle_weight=1.0-1.0/(1.0+exp(-offset_angle/1.8));
			///根据两个结果选择最优结果,中心点选择万集雷达,角度选择两值加权,轴距已以2750为基准作卡尔曼滤波
			///车长以大疆雷达为准,车宽以万集雷达为准,高以大疆雷达为准
			t_car_information_result.center_x = t_car_information_by_wanji.center_x;
			t_car_information_result.center_y = t_car_information_by_wanji.center_y;

			t_car_information_result.car_angle =angle_weight * t_car_information_by_wanji.car_angle +
												(1.0-angle_weight) * t_car_information_by_livox.car_angle;

			t_car_information_result.car_length = t_car_information_by_livox.car_length;
			t_car_information_result.car_width = t_car_information_by_livox.car_width;
			t_car_information_result.car_height = t_car_information_by_livox.car_height;

			float dj_distance = fabs(t_car_information_by_livox.wheel_base - 2750);
			float wj_distance = fabs(t_car_information_by_wanji.wheel_base - 2750);
			float weight_dj = wj_distance / (dj_distance + wj_distance);
			float weight_wj = dj_distance / (dj_distance + wj_distance);
			t_car_information_result.wheel_base = weight_dj * t_car_information_by_livox.wheel_base +
													  weight_wj * t_car_information_by_wanji.wheel_base;
			t_car_information_result.wheel_base=t_car_information_result.wheel_base>3000?3000:t_car_information_result.wheel_base;

			t_car_information_result.wheel_width = t_car_information_by_wanji.wheel_width;
			t_car_information_result.correctness = true;
		}
	}
	else if( t_car_information_by_livox.correctness == true && t_car_information_by_wanji.correctness == false )
	{
		t_car_information_result = t_car_information_by_livox;
		t_result.set_error_level_down(NEGLIGIBLE_ERROR);
	}
	else if( t_car_information_by_livox.correctness == false && t_car_information_by_wanji.correctness == true )
	{
		Common_data::copy_data(t_car_information_by_wanji, t_car_information_result);
		t_result.set_error_level_down(NEGLIGIBLE_ERROR);
	}



	//第七步, 创建一条答复消息
	message::Measure_response_msg t_measure_response_msg;
	t_measure_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_response_msg);
	t_measure_response_msg.mutable_base_info()->set_timeout_ms(5000);
	t_measure_response_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
	t_measure_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);

	t_measure_response_msg.set_command_key(command_info);
	t_measure_response_msg.set_terminal_id(terminal_id);
	t_measure_response_msg.mutable_error_manager()->set_error_code(t_result.get_error_code());
	t_measure_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_result.get_error_level());
	t_measure_response_msg.mutable_error_manager()->set_error_description(t_result.get_error_description(), t_result.get_description_length());

	t_measure_response_msg.mutable_locate_information()->set_locate_x(t_car_information_result.center_x);
	t_measure_response_msg.mutable_locate_information()->set_locate_y(t_car_information_result.center_y);
	t_measure_response_msg.mutable_locate_information()->set_locate_angle(t_car_information_result.car_angle);
	t_measure_response_msg.mutable_locate_information()->set_locate_length(t_car_information_result.car_length);
	t_measure_response_msg.mutable_locate_information()->set_locate_width(t_car_information_result.car_width);
	t_measure_response_msg.mutable_locate_information()->set_locate_height(t_car_information_result.car_height);
	t_measure_response_msg.mutable_locate_information()->set_locate_wheel_base(t_car_information_result.wheel_base);
	t_measure_response_msg.mutable_locate_information()->set_locate_wheel_width(t_car_information_result.wheel_width);
	t_measure_response_msg.mutable_locate_information()->set_locate_front_theta(t_car_information_result.front_theta);
	t_measure_response_msg.mutable_locate_information()->set_locate_correct(t_car_information_result.correctness);


	string t_msg = t_measure_response_msg.SerializeAsString();
	System_communication::get_instance_references().encapsulate_msg(t_msg);

	std::cout << "huli t_measure_response_msg = " << t_measure_response_msg.DebugString() << std::endl;


	return ;







/*
	message::Measure_response_msg t_measure_response_msg;
	t_measure_response_msg.mutable_base_info()->set_msg_type(message::Message_type::eLocate_response_msg);
	t_measure_response_msg.mutable_base_info()->set_timeout_ms(5000);
	t_measure_response_msg.mutable_base_info()->set_sender(message::Communicator::eMeasurer);
	t_measure_response_msg.mutable_base_info()->set_receiver(message::Communicator::eMain);

	t_measure_response_msg.set_command_key(command_info);
	t_measure_response_msg.set_terminal_id(terminal_id);
	t_measure_response_msg.mutable_error_manager()->set_error_code(t_error.get_error_code());
	t_measure_response_msg.mutable_error_manager()->set_error_level((message::Error_level)t_error.get_error_level());
	t_measure_response_msg.mutable_error_manager()->set_error_description(t_error.get_error_description(), t_error.get_description_length());

	if ( t_error == Error_code::SUCCESS )
	{
		t_measure_response_msg.mutable_locate_information()->set_locate_x(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_y(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_angle(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_length(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_width(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_height(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_wheel_base(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_wheel_width(0);
		t_measure_response_msg.mutable_locate_information()->set_locate_correct(0);
	}

	string t_msg = t_measure_response_msg.SerializeAsString();
	System_communication::get_instance_references().encapsulate_msg(t_msg);

	std::cout << "huli t_measure_response_msg = " << t_measure_response_msg.DebugString() << std::endl;
*/

	return ;
}




//签收预测的答复消息, (不能传引用)
void System_executor::execute_for_predict(std::string message_string)
{
	Locate_manager::get_instance_references().get_point_sift()->get_predict_with_network().execute_for_predict(message_string);
}