measure_module/laser/laser_manager_task.cpp

/*
 * Laser_manager_task 是雷达管理的任务单。
 * 外部通过它对 Laser_manager 下发任务。
 *
//用法：上级直接调用 Laser_manager 的接口函数 execute_task ，并将 Laser_manager_task 类作为参数传递
// Laser_manager 类则按照 Laser_manager_task 的功能码和指定的参数，执行相应的功能
//并将结果填充到 Laser_manager_task ，返回给上级。
 *
 *
 * */

#include "laser_manager_task.h"


//构造函数，构造函数锁定任务类型为 LASER_MANGER_SCAN_TASK ，后续不允许更改
Laser_manager_task::Laser_manager_task()
{
//构造函数锁定任务类型为 LASER_MANGER_SCAN_TASK，后续不允许更改
	m_task_type = LASER_MANGER_SCAN_TASK;
	m_task_statu = TASK_CREATED;
	m_task_statu_information.clear();
	m_task_error_manager.error_manager_clear_all();

	m_task_frame_maxnum = 0;
	m_task_save_flag = false;//默认不保存，false
	m_task_save_path.clear();
	mp_task_point_cloud_map = NULL;
	mp_task_cloud_lock=NULL;
	m_cloud_aggregation_flag = false;

	m_select_all_laser_flag = true;
	m_select_laser_id_vector.clear();
}

//析构函数
Laser_manager_task::~Laser_manager_task()
{

}

//初始化任务单，必须初始化之后才可以使用，（必选参数）
// input:p_task_cloud_lock 三维点云的数据保护锁
// output:p_task_point_cloud 三维点云容器的智能指针
//注：task_frame_maxnum默认为0，如果为0，则使用laser默认的点云的采集帧数最大值 TASK_FRAME_MAXNUM_DEFAULT
Error_manager Laser_manager_task::task_init(std::mutex* p_task_cloud_lock,
											std::map<int,pcl::PointCloud<pcl::PointXYZ>::Ptr>* p_task_point_cloud_map)
{
	if(p_task_point_cloud_map == NULL)
	{
		return Error_manager(POINTER_IS_NULL, MINOR_ERROR,
							 "Laser_task::task_init p_task_point_cloud is null");
	}
	if(p_task_cloud_lock==NULL)
	{
		return Error_manager(POINTER_IS_NULL,MINOR_ERROR,
							 "Laser_manager_task::task_init p_task_cloud_lock is null");
	}

	m_task_statu = TASK_CREATED;
	m_task_statu_information.clear();
	m_task_error_manager.error_manager_clear_all();

	m_task_frame_maxnum = 0;
	m_task_save_flag = false;
	m_task_save_path.clear();
	mp_task_cloud_lock=p_task_cloud_lock;
	mp_task_point_cloud_map = p_task_point_cloud_map;
	m_cloud_aggregation_flag = false;

	m_select_all_laser_flag = true;
	m_select_laser_id_vector.clear();

	return Error_code::SUCCESS;
}

//初始化任务单，必须初始化之后才可以使用，（可选参数）
//    input:task_statu 任务状态
//    input:task_statu_information 状态说明
//    input:tast_receiver 接受对象
//    input:task_over_time 超时时间
//    input:task_frame_maxnum 点云的采集帧数最大值
//    input:task_save_flag 是否保存
//    input:task_save_path 保存路径
//    input:p_task_cloud_lock 三维点云的数据保护锁
//    output:p_task_point_cloud 三维点云容器的智能指针
//    input:m_is_select_all_laser 是否选取所有的雷达
//    input:select_laser_number_vector 选取的指定雷达id
//注：task_frame_maxnum默认为0，如果为0，则使用laser默认的点云的采集帧数最大值 TASK_FRAME_MAXNUM_DEFAULT
Error_manager Laser_manager_task::task_init(Task_statu task_statu,
											std::string task_statu_information,
											void* p_tast_receiver,
											std::chrono::milliseconds task_over_time,
											bool task_save_flag,
											std::string task_save_path,
											std::mutex* p_task_cloud_lock,
											std::map<int,pcl::PointCloud<pcl::PointXYZ>::Ptr>* p_task_point_cloud_map,
											bool cloud_aggregation_flag,
											unsigned int task_frame_maxnum,
											bool select_all_laser_flag,
											std::vector<int> select_laser_id_vector
)
{
	if(p_task_point_cloud_map == NULL)
	{
		return Error_manager(POINTER_IS_NULL, MINOR_ERROR,
							 "Laser_task::task_init p_task_point_cloud is null");
	}
	if(p_task_cloud_lock==NULL)
	{
		return Error_manager(POINTER_IS_NULL,MINOR_ERROR,
							 "Laser_manager_task::task_init p_task_cloud_lock is null");
	}

	m_task_statu = task_statu;
	m_task_statu_information = task_statu_information;
	mp_tast_receiver = p_tast_receiver;
	m_task_over_time = task_over_time;
	m_task_error_manager.error_manager_clear_all();

	m_task_frame_maxnum = task_frame_maxnum;
	m_task_save_flag = task_save_flag;
	m_task_save_path = task_save_path;
	mp_task_cloud_lock=p_task_cloud_lock;
	mp_task_point_cloud_map = p_task_point_cloud_map;
	m_cloud_aggregation_flag = cloud_aggregation_flag;

	m_select_all_laser_flag = select_all_laser_flag;
	m_select_laser_id_vector = select_laser_id_vector;

	return Error_code::SUCCESS;
}



//把 Laser_manager_task 转化为 Laser_task，注意 task_statu 从外部载入。
//output：p_laser_task 雷达扫描任务的指针，
//input：laser_index 雷达编号
//input：p_laser_base 接受任务的 子雷达
//input：task_statu 外部载入的任务状态，默认为 TASK_CREATED
//input：task_over_time 超时时间，一般要比上级任务的时间短一些
Error_manager Laser_manager_task::trans_to_laser_task(Laser_task * p_laser_task, int laser_index,Laser_base* p_laser_base,
													  Task_statu task_statu,
													  std::chrono::milliseconds task_over_time)
{
	if ( p_laser_task ==NULL || p_laser_base == NULL )
	{
		return Error_manager(Error_code::POINTER_IS_NULL, Error_level::MINOR_ERROR,
							" trans_to_laser_task input parameter POINTER_IS_NULL ");
	}

	//该子任务存放在哪个cloud map
	int map_index;
	if ( m_cloud_aggregation_flag  )
	{
		//如果汇总, 就全部存放于map[0]
		map_index = 0;
	}
	else
	{
		//如果不汇总, 就分开存放于map[laser_index]
		map_index = laser_index;
	}

	//查看map[map_index] 是否存在
	if ( mp_task_point_cloud_map->count(map_index) == 0 )
	{
		pcl::PointCloud<pcl::PointXYZ>::Ptr tp_cloud(new pcl::PointCloud<pcl::PointXYZ>);
		(*mp_task_point_cloud_map)[map_index] = tp_cloud;

		p_laser_task->task_init(task_statu,
								m_task_statu_information,
								p_laser_base,
								task_over_time,
								m_task_frame_maxnum,
								m_task_save_flag,
								m_task_save_path,
								mp_task_cloud_lock,
								tp_cloud
		);
	}
	else
	{
		pcl::PointCloud<pcl::PointXYZ>::Ptr tp_cloud = (*mp_task_point_cloud_map)[map_index];

		p_laser_task->task_init(task_statu,
								m_task_statu_information,
								p_laser_base,
								task_over_time,
								m_task_frame_maxnum,
								m_task_save_flag,
								m_task_save_path,
								mp_task_cloud_lock,
								tp_cloud
		);
	}

	return Error_code::SUCCESS;
}



//获取 点云的采集帧数最大值
unsigned int Laser_manager_task::get_task_frame_maxnum()
{
	return m_task_frame_maxnum;
}
//获取采集的点云保存文件的使能标志位
bool Laser_manager_task::get_task_save_flag()
{
	return m_task_save_flag;
}
//获取采集的点云保存路径
std::string Laser_manager_task::get_task_save_path()
{
	return m_task_save_path;
}

//获取 三维点云容器的锁
std::mutex* Laser_manager_task::get_task_cloud_lock()
{
	return mp_task_cloud_lock;
}
//获取 三维点云容器的智能指针map
std::map<int,pcl::PointCloud<pcl::PointXYZ>::Ptr>* Laser_manager_task::get_task_point_cloud_map()
{
	return mp_task_point_cloud_map;
}
//获取 所有雷达的三维点云是否聚集的标志位
bool Laser_manager_task::get_cloud_aggregation_flag()
{
	return m_cloud_aggregation_flag;
}



//设置 点云的采集帧数最大值
void Laser_manager_task::set_task_frame_maxnum(unsigned int task_frame_maxnum)
{
	m_task_frame_maxnum = task_frame_maxnum;

}
//设置采集的点云保存文件的使能标志位
void Laser_manager_task::set_task_save_flag(bool task_save_flag)
{
	m_task_save_flag=task_save_flag;
}
//设置采集的点云保存路径
void Laser_manager_task::set_task_save_path(std::string task_save_path)
{
	m_task_save_path=task_save_path;
}
//设置采集的点云保存标志位和路径
void Laser_manager_task::set_task_save_flag_and_path(bool task_save_flag, std::string task_save_path)
{
	m_task_save_flag=task_save_flag;
	m_task_save_path=task_save_path;
}
//设置 三维点云容器的锁
void Laser_manager_task::set_task_cloud_lock(std::mutex* mp_task_cloud_lock)
{
	mp_task_cloud_lock = mp_task_cloud_lock;
}
//设置 三维点云容器的智能指针
void Laser_manager_task::set_task_point_cloud(std::map<int,pcl::PointCloud<pcl::PointXYZ>::Ptr>* p_task_point_cloud_map)
{
	mp_task_point_cloud_map = p_task_point_cloud_map;
}
//设置 所有雷达的三维点云是否聚集的标志位
void Laser_manager_task::set_cloud_aggregation_flag(bool cloud_aggregation_flag)
{
	m_cloud_aggregation_flag = cloud_aggregation_flag;
}

//获取 是否选取所有的雷达
bool Laser_manager_task::get_select_all_laser_flag()
{
	return m_select_all_laser_flag;
}
//设置 是否选取所有的雷达
void Laser_manager_task::set_select_all_laser_flag( bool select_all_laser_flag)
{
	m_select_all_laser_flag = select_all_laser_flag;
}
//获取 被选中的雷达编号。
std::vector<int>& Laser_manager_task::get_select_laser_id_vector()
{
	return m_select_laser_id_vector;
}
//设置 被选中的雷达编号。
void Laser_manager_task::set_select_laser_id_vector(std::vector<int>& select_laser_id_vector)
{
	m_select_laser_id_vector = select_laser_id_vector;
}