apollo::perception::camera::DataProvider类 参考

#include <data_provider.h>

apollo::perception::camera::DataProvider 的协作图:

类
struct	ImageOptions
struct	InitOptions

Public 成员函数
	DataProvider ()=default
	~DataProvider ()=default
	DataProvider (const DataProvider &)=delete
DataProvider &	operator= (const DataProvider &)=delete
bool	Init (const InitOptions &options=InitOptions())
bool	FillImageData (int rows, int cols, const uint8_t *data, const std::string &encoding)
bool	GetImageBlob (const ImageOptions &options, base::Blob< uint8_t > *blob)
bool	GetImage (const ImageOptions &options, base::Image8U *image)
int	src_height () const
int	src_width () const
const std::string &	sensor_name () const
bool	to_gray_image ()
bool	to_rgb_image ()
bool	to_bgr_image ()

Protected 属性
std::string	sensor_name_
int	src_height_ = 0
int	src_width_ = 0
int	device_id_ = -1
std::shared_ptr< base::Image8U >	ori_gray_
std::shared_ptr< base::Image8U >	ori_rgb_
std::shared_ptr< base::Image8U >	ori_bgr_
std::shared_ptr< base::Image8U >	gray_
std::shared_ptr< base::Image8U >	rgb_
std::shared_ptr< base::Image8U >	bgr_
bool	gray_ready_ = false
bool	rgb_ready_ = false
bool	bgr_ready_ = false
base::Blob< float >	temp_float_
base::Blob< uint8_t >	temp_uint8_
std::shared_ptr< UndistortionHandler >	handler_ = nullptr

详细描述

在文件 data_provider.h 第 30 行定义.

构造及析构函数说明

DataProvider() [1/2]

apollo::perception::camera::DataProvider::DataProvider ( )

default

~DataProvider()

apollo::perception::camera::DataProvider::~DataProvider ( )

default

DataProvider() [2/2]

apollo::perception::camera::DataProvider::DataProvider ( const DataProvider &  )

delete

成员函数说明

FillImageData()

bool apollo::perception::camera::DataProvider::FillImageData	(	int	rows,
		int	cols,
		const uint8_t *	data,
		const std::string &	encoding
	)

在文件 data_provider.cc 第 113 行定义.

                                                            {
  if (cudaSetDevice(device_id_) != cudaSuccess) {
    AERROR << "Failed to set device to: " << device_id_;
    return false;
  }
 
  gray_ready_ = false;
  rgb_ready_ = false;
  bgr_ready_ = false;
 
  bool success = false;
 
#if USE_GPU == 0  // copy to host memory
  AINFO << "Fill in CPU mode ...";
  if (handler_ != nullptr) {
    AERROR << "Undistortion DO NOT support CPU mode!";
    return false;
  }
  if (encoding == "rgb8") {
    memcpy(rgb_->mutable_cpu_data(), data, rgb_->count() * sizeof(data[0]));
    rgb_ready_ = true;
    success = true;
  } else if (encoding == "bgr8") {
    memcpy(bgr_->mutable_cpu_data(), data, bgr_->count() * sizeof(data[0]));
    bgr_ready_ = true;
    success = true;
  } else if (encoding == "gray" || encoding == "y") {
    memcpy(gray_->mutable_cpu_data(), data, gray_->count() * sizeof(data[0]));
    gray_ready_ = true;
    success = true;
  } else {
    AERROR << "Unrecognized image encoding: " << encoding;
  }
#else  // copy to device memory directly
  AINFO << "Fill in GPU mode ...";
  if (encoding == "rgb8") {
    if (handler_ != nullptr) {
      cudaMemcpy(ori_rgb_->mutable_gpu_data(), data,
                 ori_rgb_->rows() * ori_rgb_->width_step(), cudaMemcpyDefault);
      success = handler_->Handle(*ori_rgb_, rgb_.get());
    } else {
      cudaMemcpy(rgb_->mutable_gpu_data(), data,
                 rgb_->rows() * rgb_->width_step(), cudaMemcpyDefault);
      success = true;
    }
    rgb_ready_ = true;
  } else if (encoding == "bgr8") {
    if (handler_ != nullptr) {
      cudaMemcpy(ori_bgr_->mutable_gpu_data(), data,
                 ori_bgr_->rows() * ori_bgr_->width_step(), cudaMemcpyDefault);
      success = handler_->Handle(*ori_bgr_, bgr_.get());
    } else {
      cudaMemcpy(bgr_->mutable_gpu_data(), data,
                 bgr_->rows() * bgr_->width_step(), cudaMemcpyDefault);
      success = true;
    }
    bgr_ready_ = true;
  } else if (encoding == "gray" || encoding == "y") {
    if (handler_ != nullptr) {
      cudaMemcpy(ori_gray_->mutable_gpu_data(), data,
                 ori_gray_->rows() * ori_gray_->width_step(),
                 cudaMemcpyDefault);
      success = handler_->Handle(*ori_gray_, gray_.get());
    } else {
      cudaMemcpy(gray_->mutable_gpu_data(), data,
                 gray_->rows() * gray_->width_step(), cudaMemcpyDefault);
      success = true;
    }
    gray_ready_ = true;
  } else {
    AERROR << "Unrecognized image encoding: " << encoding;
  }
#endif
 
  AINFO << "Done! (" << success << ")";
  return success;
}

GetImage()

bool apollo::perception::camera::DataProvider::GetImage	(	const ImageOptions &	options,
		base::Image8U *	image
	)

在文件 data_provider.cc 第 231 行定义.

                                                {
  AINFO << "GetImage ...";
  if (image == nullptr) {
    return false;
  }
  bool success = false;
  switch (options.target_color) {
    case base::Color::RGB:
      success = to_rgb_image();
      *image = (*rgb_);
      break;
    case base::Color::BGR:
      success = to_bgr_image();
      *image = (*bgr_);
      break;
    case base::Color::GRAY:
      success = to_gray_image();
      *image = (*gray_);
      break;
    default:
      AERROR << "Unsupported Color: "
             << static_cast<uint8_t>(options.target_color);
  }
  if (!success) {
    return false;
  }
 
  if (options.do_crop) {
    AINFO << "\tcropping ...";
    *image = (*image)(options.crop_roi);
  }
  AINFO << "Done!";
  return true;
}

GetImageBlob()

bool apollo::perception::camera::DataProvider::GetImageBlob	(	const ImageOptions &	options,
		base::Blob< uint8_t > *	blob
	)

在文件 data_provider.cc 第 221 行定义.

                                                         {
  base::Image8U image;
  if (!GetImage(options, &image)) {
    return false;
  }
  imageToBlob(image, blob);
  return true;
}

Init()

bool apollo::perception::camera::DataProvider::Init

(

const InitOptions &

options = InitOptions()

)

在文件 data_provider.cc 第 25 行定义.

                                                              {
  src_height_ = options.image_height;
  src_width_ = options.image_width;
  sensor_name_ = options.sensor_name;
  device_id_ = options.device_id;
 
  if (cudaSetDevice(device_id_) != cudaSuccess) {
    AERROR << "Failed to set device to: " << device_id_;
    return false;
  }
 
  // Initialize uint8 blobs
  gray_.reset(new base::Image8U(src_height_, src_width_, base::Color::GRAY));
  rgb_.reset(new base::Image8U(src_height_, src_width_, base::Color::RGB));
  bgr_.reset(new base::Image8U(src_height_, src_width_, base::Color::BGR));
 
  // Allocate CPU memory for uint8 blobs
  gray_->cpu_data();
  rgb_->cpu_data();
  bgr_->cpu_data();
 
  // Allocate GPU memory for uint8 blobs
  gray_->gpu_data();
  rgb_->gpu_data();
  bgr_->gpu_data();
 
  if (options.do_undistortion) {
    handler_.reset(new UndistortionHandler());
    if (!handler_->Init(options.sensor_name, device_id_)) {
      return false;
    }
    // Initialize uint8 blobs
    ori_gray_.reset(
        new base::Image8U(src_height_, src_width_, base::Color::GRAY));
    ori_rgb_.reset(
        new base::Image8U(src_height_, src_width_, base::Color::RGB));
    ori_bgr_.reset(
        new base::Image8U(src_height_, src_width_, base::Color::BGR));
 
    // Allocate CPU memory for uint8 blobs
    ori_gray_->cpu_data();
    ori_rgb_->cpu_data();
    ori_bgr_->cpu_data();
 
    // Allocate GPU memory for uint8 blobs
    ori_gray_->gpu_data();
    ori_rgb_->gpu_data();
    ori_bgr_->gpu_data();
  }
 
  // Warm up nppi functions
  {
    bgr_ready_ = false;
    rgb_ready_ = true;
    gray_ready_ = false;
    to_bgr_image();
    bgr_ready_ = false;
    rgb_ready_ = false;
    gray_ready_ = true;
    to_bgr_image();
  }
  {
    bgr_ready_ = false;
    rgb_ready_ = false;
    gray_ready_ = true;
    to_rgb_image();
    bgr_ready_ = true;
    rgb_ready_ = false;
    gray_ready_ = false;
    to_rgb_image();
  }
  {
    bgr_ready_ = false;
    rgb_ready_ = true;
    gray_ready_ = false;
    to_gray_image();
    bgr_ready_ = true;
    rgb_ready_ = false;
    gray_ready_ = false;
    to_gray_image();
  }
  bgr_ready_ = false;
  rgb_ready_ = false;
  gray_ready_ = false;
 
  return true;
}

operator=()

DataProvider & apollo::perception::camera::DataProvider::operator= ( const DataProvider &  )

delete

sensor_name()

const std::string & apollo::perception::camera::DataProvider::sensor_name ( ) const

inline

在文件 data_provider.h 第 111 行定义.

{ return sensor_name_; }

src_height()

int apollo::perception::camera::DataProvider::src_height ( ) const

inline

在文件 data_provider.h 第 109 行定义.

{ return src_height_; }

src_width()

int apollo::perception::camera::DataProvider::src_width ( ) const

inline

在文件 data_provider.h 第 110 行定义.

{ return src_width_; }

to_bgr_image()

bool apollo::perception::camera::DataProvider::to_bgr_image

(

)

在文件 data_provider.cc 第 303 行定义.

                                {
  if (!bgr_ready_) {
    if (rgb_ready_) {
      const int order[] = {2, 1, 0};
      swapImageChannels(rgb_, bgr_, src_width_, src_height_, order);
      bgr_ready_ = true;
    } else if (gray_ready_) {
      dupImageChannels(gray_, bgr_, src_width_, src_height_);
      bgr_ready_ = true;
    } else {
      AWARN << "No image data filled yet, return uninitialized blob!";
      return false;
    }
  }
  return true;
}

to_gray_image()

bool apollo::perception::camera::DataProvider::to_gray_image

(

)

在文件 data_provider.cc 第 267 行定义.

                                 {
  if (!gray_ready_) {
    if (bgr_ready_) {
      float coeffs[] = {0.114f, 0.587f, 0.299f};
      imageToGray(bgr_, gray_, src_width_, src_height_, coeffs);
      gray_ready_ = true;
    } else if (rgb_ready_) {
      float coeffs[] = {0.299f, 0.587f, 0.114f};
      imageToGray(rgb_, gray_, src_width_, src_height_, coeffs);
      gray_ready_ = true;
    } else {
      AWARN << "No image data filled yet, return uninitialized blob!";
      return false;
    }
  }
  return true;
}

to_rgb_image()

bool apollo::perception::camera::DataProvider::to_rgb_image

(

)

在文件 data_provider.cc 第 285 行定义.

                                {
  if (!rgb_ready_) {
    if (bgr_ready_) {
      // BGR2RGB takes less than 0.010ms on K2200
      const int order[] = {2, 1, 0};
      swapImageChannels(bgr_, rgb_, src_width_, src_height_, order);
      rgb_ready_ = true;
    } else if (gray_ready_) {
      dupImageChannels(gray_, rgb_, src_width_, src_height_);
      rgb_ready_ = true;
    } else {
      AWARN << "No image data filled yet, return uninitialized blob!";
      return false;
    }
  }
  return true;
}

类成员变量说明

bgr_

std::shared_ptr<base::Image8U> apollo::perception::camera::DataProvider::bgr_

protected

在文件 data_provider.h 第 128 行定义.

bgr_ready_

bool apollo::perception::camera::DataProvider::bgr_ready_ = false

protected

在文件 data_provider.h 第 131 行定义.

device_id_

int apollo::perception::camera::DataProvider::device_id_ = -1

protected

在文件 data_provider.h 第 121 行定义.

gray_

std::shared_ptr<base::Image8U> apollo::perception::camera::DataProvider::gray_

protected

在文件 data_provider.h 第 126 行定义.

gray_ready_

bool apollo::perception::camera::DataProvider::gray_ready_ = false

protected

在文件 data_provider.h 第 129 行定义.

handler_

std::shared_ptr<UndistortionHandler> apollo::perception::camera::DataProvider::handler_ = nullptr

protected

在文件 data_provider.h 第 135 行定义.

ori_bgr_

std::shared_ptr<base::Image8U> apollo::perception::camera::DataProvider::ori_bgr_

protected

在文件 data_provider.h 第 125 行定义.

ori_gray_

std::shared_ptr<base::Image8U> apollo::perception::camera::DataProvider::ori_gray_

protected

在文件 data_provider.h 第 123 行定义.

ori_rgb_

std::shared_ptr<base::Image8U> apollo::perception::camera::DataProvider::ori_rgb_

protected

在文件 data_provider.h 第 124 行定义.

rgb_

std::shared_ptr<base::Image8U> apollo::perception::camera::DataProvider::rgb_

protected

在文件 data_provider.h 第 127 行定义.

rgb_ready_

bool apollo::perception::camera::DataProvider::rgb_ready_ = false

protected

在文件 data_provider.h 第 130 行定义.

sensor_name_

std::string apollo::perception::camera::DataProvider::sensor_name_

protected

在文件 data_provider.h 第 118 行定义.

src_height_

int apollo::perception::camera::DataProvider::src_height_ = 0

protected

在文件 data_provider.h 第 119 行定义.

src_width_

int apollo::perception::camera::DataProvider::src_width_ = 0

protected

在文件 data_provider.h 第 120 行定义.

temp_float_

base::Blob<float> apollo::perception::camera::DataProvider::temp_float_

protected

在文件 data_provider.h 第 133 行定义.

temp_uint8_

base::Blob<uint8_t> apollo::perception::camera::DataProvider::temp_uint8_

protected

在文件 data_provider.h 第 134 行定义.

---

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

• modules/perception/common/camera/common/data_provider.h
• modules/perception/common/camera/common/data_provider.cc