apollo::perception::trafficlight::SemanticReviser类 参考

#include <semantic_decision.h>

类 apollo::perception::trafficlight::SemanticReviser 继承关系图:

apollo::perception::trafficlight::SemanticReviser 的协作图:

Public 成员函数
	SemanticReviser ()
	Construct a new semantic reviser object.
	~SemanticReviser ()=default
	Destroy the semantic reviser object.
bool	Init (const TrafficLightTrackerInitOptions &options=TrafficLightTrackerInitOptions()) override
	Initialize semantic reviser parameters.
bool	Track (camera::TrafficLightFrame *frame) override
	Track detected traffic_light.
base::TLColor	ReviseBySemantic (SemanticTable semantic_table, std::vector< base::TrafficLightPtr > *lights)
	Correction based on semantic information.
void	ReviseByTimeSeries (double time_stamp, SemanticTable semantic_table, std::vector< base::TrafficLightPtr > *lights)
	Correction based on timeseries information.
void	UpdateHistoryAndLights (const SemanticTable &cur, std::vector< base::TrafficLightPtr > *lights, std::vector< SemanticTable >::iterator *history)
	Update the traffic light history information.
void	ReviseLights (std::vector< base::TrafficLightPtr > *lights, const std::vector< int > &light_ids, base::TLColor dst_color)
	Revise and tracking traffic light.
Public 成员函数 继承自 apollo::perception::trafficlight::BaseTrafficLightTracker
	BaseTrafficLightTracker ()=default
	Construct a new base traffic light tracker object.
virtual	~BaseTrafficLightTracker ()=default
	Destroy the base traffic light tracker object.
	DISALLOW_COPY_AND_ASSIGN (BaseTrafficLightTracker)

详细描述

在文件 semantic_decision.h 第 47 行定义.

构造及析构函数说明

SemanticReviser()

apollo::perception::trafficlight::SemanticReviser::SemanticReviser

(

)

Construct a new semantic reviser object.

在文件 semantic_decision.cc 第 40 行定义.

    : revise_time_s_(1.5f),
      blink_threshold_s_(0.4f),
      non_blink_threshold_s_(0.8f),
      hysteretic_threshold_(1) {}

~SemanticReviser()

apollo::perception::trafficlight::SemanticReviser::~SemanticReviser ( )

default

Destroy the semantic reviser object.

成员函数说明

Init()

bool apollo::perception::trafficlight::SemanticReviser::Init ( const TrafficLightTrackerInitOptions &  options = TrafficLightTrackerInitOptions() )

overridevirtual

Initialize semantic reviser parameters.

参数

options

返回

true

false

实现了 apollo::perception::trafficlight::BaseTrafficLightTracker.

在文件 semantic_decision.cc 第 46 行定义.

                                                                        {
  std::string config_file =
      GetConfigFile(options.config_path, options.config_file);
 
  if (!cyber::common::GetProtoFromFile(config_file, &semantic_param_)) {
    AERROR << "load proto param failed, root dir: " << config_file;
    return false;
  }
 
  int non_blink_coef = 2;
  revise_time_s_ = semantic_param_.revise_time_second();
  blink_threshold_s_ = semantic_param_.blink_threshold_second();
  hysteretic_threshold_ = semantic_param_.hysteretic_threshold_count();
  non_blink_threshold_s_ =
      blink_threshold_s_ * static_cast<float>(non_blink_coef);
 
  ADEBUG << "revise_time_s_: " << revise_time_s_;
  ADEBUG << "blink_threshold_s_: " << blink_threshold_s_;
  ADEBUG << "hysteretic_threshold_: " << hysteretic_threshold_;
 
  return true;
}

ReviseBySemantic()

base::TLColor apollo::perception::trafficlight::SemanticReviser::ReviseBySemantic	(	SemanticTable	semantic_table,
		std::vector< base::TrafficLightPtr > *	lights
	)

Correction based on semantic information.

参数

semantic_table
lights

返回

base::TLColor

在文件 semantic_decision.cc 第 96 行定义.

                                                                          {
  std::vector<int> vote(static_cast<int>(base::TLColor::TL_TOTAL_COLOR_NUM), 0);
  std::vector<base::TrafficLightPtr> &lights_ref = *lights;
  base::TLColor max_color = base::TLColor::TL_UNKNOWN_COLOR;
 
  for (size_t i = 0; i < semantic_table.light_ids.size(); ++i) {
    int index = semantic_table.light_ids.at(i);
    base::TrafficLightPtr light = lights_ref[index];
    auto color = light->status.color;
    vote.at(static_cast<int>(color))++;
  }
 
  if ((vote.at(static_cast<size_t>(base::TLColor::TL_RED)) == 0) &&
      (vote.at(static_cast<size_t>(base::TLColor::TL_GREEN)) == 0) &&
      (vote.at(static_cast<size_t>(base::TLColor::TL_YELLOW)) == 0)) {
    if (vote.at(static_cast<size_t>(base::TLColor::TL_BLACK)) > 0) {
      return base::TLColor::TL_BLACK;
    } else {
      return base::TLColor::TL_UNKNOWN_COLOR;
    }
  }
 
  vote.at(static_cast<size_t>(base::TLColor::TL_BLACK)) = 0;
  vote.at(static_cast<size_t>(base::TLColor::TL_UNKNOWN_COLOR)) = 0;
 
  auto biggest = std::max_element(std::begin(vote), std::end(vote));
 
  int max_color_num = *biggest;
  max_color = base::TLColor(std::distance(std::begin(vote), biggest));
 
  vote.erase(biggest);
 
  auto second_biggest = std::max_element(std::begin(vote), std::end(vote));
 
  ADEBUG << "color " << s_color_strs[max_color] << " is max " << max_color_num;
 
  if (max_color_num == *second_biggest) {
    return base::TLColor::TL_UNKNOWN_COLOR;
  } else {
    return max_color;
  }
}

ReviseByTimeSeries()

void apollo::perception::trafficlight::SemanticReviser::ReviseByTimeSeries	(	double	time_stamp,
		SemanticTable	semantic_table,
		std::vector< base::TrafficLightPtr > *	lights
	)

Correction based on timeseries information.

参数

time_stamp
semantic_table
lights

在文件 semantic_decision.cc 第 151 行定义.

                                            {
  ADEBUG << "revise " << semantic_table.semantic
         << ", lights number:" << semantic_table.light_ids.size();
 
  std::vector<base::TrafficLightPtr> &lights_ref = *lights;
  base::TLColor cur_color = ReviseBySemantic(semantic_table, lights);
  base::TLColor pre_color = base::TLColor::TL_UNKNOWN_COLOR;
  semantic_table.color = cur_color;
  semantic_table.time_stamp = time_stamp;
  ADEBUG << "revise same semantic lights";
  ReviseLights(lights, semantic_table.light_ids, cur_color);
 
  std::vector<SemanticTable>::iterator iter =
      std::find_if(std::begin(history_semantic_), std::end(history_semantic_),
                   boost::bind(compare, _1, semantic_table));
 
  if (iter != history_semantic_.end()) {
    pre_color = iter->color;
    if (time_stamp - iter->time_stamp < revise_time_s_) {
      ADEBUG << "revise by time series";
      switch (cur_color) {
        case base::TLColor::TL_YELLOW:
          if (iter->color == base::TLColor::TL_RED) {
            ReviseLights(lights, semantic_table.light_ids, iter->color);
            iter->time_stamp = time_stamp;
            iter->hystertic_window.hysteretic_count = 0;
          } else {
            UpdateHistoryAndLights(semantic_table, lights, &iter);
            ADEBUG << "High confidence color " << s_color_strs[cur_color];
          }
          break;
        case base::TLColor::TL_RED:
        case base::TLColor::TL_GREEN:
          UpdateHistoryAndLights(semantic_table, lights, &iter);
          if (time_stamp - iter->last_bright_time_stamp > blink_threshold_s_ &&
              iter->last_dark_time_stamp > iter->last_bright_time_stamp) {
            iter->blink = true;
          }
          iter->last_bright_time_stamp = time_stamp;
          ADEBUG << "High confidence color " << s_color_strs[cur_color];
          break;
        case base::TLColor::TL_BLACK:
          iter->last_dark_time_stamp = time_stamp;
          iter->hystertic_window.hysteretic_count = 0;
          if (iter->color == base::TLColor::TL_UNKNOWN_COLOR ||
              iter->color == base::TLColor::TL_BLACK) {
            iter->time_stamp = time_stamp;
            UpdateHistoryAndLights(semantic_table, lights, &iter);
          } else {
            ReviseLights(lights, semantic_table.light_ids, iter->color);
          }
          break;
        case base::TLColor::TL_UNKNOWN_COLOR:
        default:
          ReviseLights(lights, semantic_table.light_ids, iter->color);
          break;
      }
    } else {
      iter->time_stamp = time_stamp;
      iter->color = cur_color;
    }
 
    // set blink status
    if (pre_color != iter->color ||
        fabs(iter->last_dark_time_stamp - iter->last_bright_time_stamp) >
            non_blink_threshold_s_) {
      iter->blink = false;
    }
 
    for (auto index : semantic_table.light_ids) {
      lights_ref[index]->status.blink =
          (iter->blink && iter->color == base::TLColor::TL_GREEN);
    }
    ADEBUG << "semantic " << semantic_table.semantic << " color "
           << s_color_strs[iter->color] << " blink " << iter->blink << " cur "
           << s_color_strs[cur_color];
    ADEBUG << "cur ts " << time_stamp;
    ADEBUG << "bri ts " << iter->last_bright_time_stamp;
    ADEBUG << "dar ts " << iter->last_dark_time_stamp;
  } else {
    semantic_table.last_dark_time_stamp = semantic_table.time_stamp;
    semantic_table.last_bright_time_stamp = semantic_table.time_stamp;
    history_semantic_.push_back(semantic_table);
  }
}

ReviseLights()

void apollo::perception::trafficlight::SemanticReviser::ReviseLights	(	std::vector< base::TrafficLightPtr > *	lights,
		const std::vector< int > &	light_ids,
		base::TLColor	dst_color
	)

Revise and tracking traffic light.

参数

lights
light_ids
dst_color

在文件 semantic_decision.cc 第 140 行定义.

                                                          {
  for (auto index : light_ids) {
    lights->at(index)->status.color = dst_color;
  }
 
  ADEBUG << "revise " << light_ids.size() << " lights to "
         << s_color_strs[dst_color];
}

Track()

bool apollo::perception::trafficlight::SemanticReviser::Track ( camera::TrafficLightFrame *  frame )

overridevirtual

Track detected traffic_light.

参数

frame

返回

true

false

实现了 apollo::perception::trafficlight::BaseTrafficLightTracker.

在文件 semantic_decision.cc 第 239 行定义.

                                                          {
  double time_stamp = frame->timestamp;
  std::vector<base::TrafficLightPtr> &lights_ref = frame->traffic_lights;
  std::vector<SemanticTable> semantic_table;
  ADEBUG << "start revise ";
 
  if (lights_ref.empty()) {
    history_semantic_.clear();
    ADEBUG << "no lights to revise, return";
    return true;
  }
 
  ADEBUG << "lights_ref size is  : " << lights_ref.size();
  for (size_t i = 0; i < lights_ref.size(); i++) {
    base::TrafficLightPtr light = lights_ref.at(i);
    int cur_semantic = light->semantic;
    ADEBUG << "light " << light->id << " semantic " << cur_semantic;
 
    SemanticTable tmp;
    std::stringstream ss;
 
    if (cur_semantic > 0) {
      ss << "Semantic_" << cur_semantic;
    } else {
      ss << "No_semantic_light_" << light->id;
    }
 
    tmp.semantic = ss.str();
    tmp.light_ids.push_back(static_cast<int>(i));
    tmp.color = light->status.color;
    tmp.time_stamp = time_stamp;
    tmp.blink = false;
    auto iter =
        std::find_if(std::begin(semantic_table), std::end(semantic_table),
                     boost::bind(compare, _1, tmp));
 
    if (iter != semantic_table.end()) {
      iter->light_ids.push_back(static_cast<int>(i));
    } else {
      semantic_table.push_back(tmp);
    }
  }
 
  ADEBUG << "semantic_table size is : " << semantic_table.size();
  for (size_t i = 0; i < semantic_table.size(); ++i) {
    SemanticTable cur_semantic_table = semantic_table.at(i);
    ReviseByTimeSeries(time_stamp, cur_semantic_table, &lights_ref);
  }
 
  return true;
}

UpdateHistoryAndLights()

void apollo::perception::trafficlight::SemanticReviser::UpdateHistoryAndLights	(	const SemanticTable &	cur,
		std::vector< base::TrafficLightPtr > *	lights,
		std::vector< SemanticTable >::iterator *	history
	)

Update the traffic light history information.

参数

cur
lights
history

在文件 semantic_decision.cc 第 69 行定义.

                                               {
  (*history)->time_stamp = cur.time_stamp;
  if ((*history)->color == base::TLColor::TL_BLACK) {
    if ((*history)->hystertic_window.hysteretic_color == cur.color) {
      (*history)->hystertic_window.hysteretic_count++;
    } else {
      (*history)->hystertic_window.hysteretic_color = cur.color;
      (*history)->hystertic_window.hysteretic_count = 1;
    }
    ADEBUG << "Black lights hysteretic change to " << s_color_strs[cur.color]
           << " count " << (*history)->hystertic_window.hysteretic_count
           << " threshold " << hysteretic_threshold_;
 
    if ((*history)->hystertic_window.hysteretic_count > hysteretic_threshold_) {
      (*history)->color = cur.color;
      (*history)->hystertic_window.hysteretic_count = 0;
      ADEBUG << "Black lights hysteretic change to " << s_color_strs[cur.color];
    } else {
      ReviseLights(lights, cur.light_ids, (*history)->color);
    }
  } else {
    (*history)->color = cur.color;
  }
}

---

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

• modules/perception/traffic_light_tracking/tracker/semantic_decision.h
• modules/perception/traffic_light_tracking/tracker/semantic_decision.cc