main_window.cc 文件参考

#include <QtWidgets/QCheckBox>
#include <QtWidgets/QColorDialog>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QMessageBox>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSpinBox>
#include "modules/tools/visualizer/fixedaspectratiowidget.h"
#include "modules/tools/visualizer/grid.h"
#include "modules/tools/visualizer/main_window.h"
#include "modules/tools/visualizer/pointcloud.h"
#include "modules/tools/visualizer/radarpoints.h"
#include "modules/tools/visualizer/ui_main_window.h"
#include "modules/tools/visualizer/video_images_dialog.h"

main_window.cc 的引用(Include)关系图:

浏览源代码.

类
struct	MainWindow::VideoImgProxy
struct	MainWindow::RadarData

宏定义
#define	MEMBER_OFFSET(StructType, Member)
#define	StructPtrByMemberPtr(MemberPtr, StructType, Member)

宏定义说明

MEMBER_OFFSET

#define MEMBER_OFFSET	(		StructType,
			Member
	)

值:

  (size_t)(                                                                  \
      reinterpret_cast<char*>(&(reinterpret_cast<StructType*>(1)->Member)) - \
      1)

在文件 main_window.cc 第 72 行定义.

                               {
  FixedAspectRatioWidget video_image_viewer_;
  QTreeWidgetItem root_item_;
  QTreeWidgetItem channel_name_item_;
  QTreeWidgetItem action_item_;
 
  QComboBox channel_name_combobox_;
  QPushButton action_item_button_;
 
  QMutex reader_mutex_;
  std::shared_ptr<Texture> dynamic_texture_;
  bool isCompressedImage_;
  union {
    CyberChannReader<apollo::drivers::Image>* image_reader_;
    CyberChannReader<apollo::drivers::CompressedImage>*
        compressed_image_reader_;
  };
 
  VideoImgProxy()
      : video_image_viewer_(),
        root_item_(),
        channel_name_item_(),
        action_item_(),
        channel_name_combobox_(),
        action_item_button_(),
        reader_mutex_(),
        dynamic_texture_(),
        isCompressedImage_(false),
        image_reader_(nullptr) {}
 
  void deleteReader(void) {
    if (image_reader_) {
      if (isCompressedImage_) {
        delete compressed_image_reader_;
      } else {
        delete image_reader_;
      }
      image_reader_ = nullptr;
      isCompressedImage_ = false;
    }
  }
 
  void CloseChannel(void) {
    if (isCompressedImage_) {
      compressed_image_reader_->CloseChannel();
    } else {
      image_reader_->CloseChannel();
    }
  }
 
  ~VideoImgProxy(void) {
    dynamic_texture_.reset();
    deleteReader();
  }
};
 
struct MainWindow::RadarData {
  QTreeWidgetItem root_item_;
  QTreeWidgetItem channel_name_item_;
  QTreeWidgetItem action_item_;
 
  QComboBox channel_name_combobox_;
  QPushButton action_item_button_;
  QCheckBox enable_checkBox_;
 
  QMutex reader_mutex_;
 
  CyberChannReader<apollo::drivers::RadarObstacles>* channel_reader_;
 
  RadarData(void)
      : root_item_(),
        channel_name_item_(),
        action_item_(),
        channel_name_combobox_(),
        action_item_button_(),
        enable_checkBox_(),
        reader_mutex_(),
        channel_reader_(nullptr) {}
 
  ~RadarData(void) {
    if (channel_reader_) {
      delete channel_reader_;
      channel_reader_ = nullptr;
    }
  }
};
 
MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent),
      ui_(new Ui::MainWindow),
      msg_dialog_(new MessageDialog),
      open_images_dialog_(nullptr),
 
      grid_(nullptr),
      enable_grid_checkBox_(nullptr),
      grid_root_item_(nullptr),
 
      pointcloud_top_item_(nullptr),
      pointcloud_comboBox_(new QComboBox),
      pointcloud_button_(new QPushButton),
      pointcloud_channel_Reader_(nullptr),
 
      pointcloud_reader_mutex_(),
 
      pointcloud_shader_(nullptr),
      grid_shader_(nullptr),
      radar_points_shader_(nullptr),
      video_image_viewer_list_(),
      closed_video_image_viewer_list_(),
      radarData_list_(),
      closed_radarData_list_(),
      _channelName2TypeMap() {
  ui_->setupUi(this);
  ui_->videoImageGridLayout->setContentsMargins(2, 2, 2, 2);
  ui_->videoImageWidget->setVisible(false);
 
  ui_->mainToolBar->addAction(ui_->actionAddGrid);
  ui_->mainToolBar->addAction(ui_->actionPointCloud);
  ui_->mainToolBar->addSeparator();
  ui_->mainToolBar->addAction(ui_->actionOpenImage);
  ui_->mainToolBar->addAction(ui_->actionOpenImages);
  ui_->mainToolBar->addAction(ui_->actionDelImage);
  ui_->mainToolBar->addSeparator();
  ui_->mainToolBar->addAction(ui_->actionPlay);
  ui_->mainToolBar->addAction(ui_->actionPause);
 
  pointcloud_reader_mutex_.lock();
 
  {
    QStringList tmp;
    tmp << "ChannelNames"
        << " ";
    all_channel_root_ = new QTreeWidgetItem(tmp);
    ui_->treeWidget->addTopLevelItem(all_channel_root_);
  }
 
  connect(ui_->actionAbout, SIGNAL(triggered(bool)), this, SLOT(showMessage()));
  connect(ui_->actionLicense, SIGNAL(triggered(bool)), this,
          SLOT(showMessage()));
 
  pointcloud_button_->setCheckable(true);
  pointcloud_button_->setStyleSheet(globalTreeItemStyle);
  pointcloud_comboBox_->setStyleSheet(globalTreeItemStyle);
 
  connect(pointcloud_button_, SIGNAL(clicked(bool)), this,
          SLOT(PlayRenderableObject(bool)));
  connect(pointcloud_comboBox_, SIGNAL(currentIndexChanged(int)), this,
          SLOT(ChangePointCloudChannel()));
 
  connect(ui_->treeWidget, SIGNAL(itemSelectionChanged()), this,
          SLOT(UpdateActions()));
  connect(ui_->treeWidget, SIGNAL(visibilityChanged(bool)), ui_->actionGlobal,
          SLOT(setChecked(bool)));
  connect(ui_->actionPlay, SIGNAL(triggered(bool)), this, SLOT(PlayPause()));
  connect(ui_->actionPause, SIGNAL(triggered(bool)), this, SLOT(PlayPause()));
}
 
MainWindow::~MainWindow() {
  for (VideoImgProxy* item : video_image_viewer_list_) {
    item->reader_mutex_.unlock();
  }
  for (VideoImgProxy* item : closed_video_image_viewer_list_) {
    item->reader_mutex_.unlock();
  }
  for (RadarData* item : radarData_list_) {
    item->reader_mutex_.unlock();
  }
  for (RadarData* item : closed_radarData_list_) {
    item->reader_mutex_.unlock();
  }
 
  pointcloud_reader_mutex_.unlock();
 
  if (pointcloud_channel_Reader_) {
    delete pointcloud_channel_Reader_;
    pointcloud_channel_Reader_ = nullptr;
  }
 
  for (VideoImgProxy* item : video_image_viewer_list_) {
    delete item;
  }
 
  for (VideoImgProxy* item : closed_video_image_viewer_list_) {
    delete item;
  }
 
  for (RadarData* item : radarData_list_) {
    delete item;
  }
 
  for (RadarData* item : closed_radarData_list_) {
    delete item;
  }
 
  delete ui_;
  delete msg_dialog_;
}
 
void MainWindow::calculateWH(void) {
  int count = video_image_viewer_list_.count();
 
  if (count > 0) {
    QSize wh;
    wh.setWidth(ui_->sceneWidget->width() - count * 2 + 2);
    wh.setHeight(50);
    wh.setWidth(wh.width() / count);
    int index = 0;
 
    for (VideoImgProxy* p : video_image_viewer_list_) {
      p->video_image_viewer_.setMinimumSize(wh);
      ui_->videoImageGridLayout->removeWidget(&p->video_image_viewer_);
      ui_->videoImageGridLayout->addWidget(&p->video_image_viewer_, index / 3,
                                           index % 3, 1, 1);
      ++index;
    }
    ui_->videoImageWidget->adjustSize();
  }
}
 
MainWindow::VideoImgProxy* MainWindow::AddVideoImgViewer() {
  std::shared_ptr<Texture> tex(new Texture);
  if (tex == nullptr) {
    return nullptr;
  }
  VideoImgProxy* ret = new VideoImgProxy();
 
  if (ret) {
    int index = video_image_viewer_list_.count();
    ret->video_image_viewer_.set_index(index);
 
    ret->video_image_viewer_.setStyleSheet("background-color:black;");
    ret->video_image_viewer_.setVisible(false);
 
    QString imgName = tr("Camera%1").arg(index);
 
    ret->root_item_.setHidden(true);
    ret->root_item_.setText(0, imgName);
    ret->root_item_.setText(1, "");
 
    ret->channel_name_item_.setText(0, "ChannelName");
    ret->action_item_.setText(0, "Action");
 
    ret->action_item_button_.setObjectName(tr("pushButton%1").arg(index));
    ret->action_item_button_.setText("Play");
    ret->action_item_button_.setCheckable(true);
    ret->action_item_button_.setStyleSheet(globalTreeItemStyle);
 
    ret->channel_name_combobox_.setObjectName(tr("comboBox%1").arg(index));
    ret->channel_name_combobox_.setStyleSheet(globalTreeItemStyle);
 
    ret->root_item_.addChild(&ret->channel_name_item_);
    ret->root_item_.addChild(&ret->action_item_);
 
    ret->dynamic_texture_ = tex;
    ret->video_image_viewer_.SetupDynamicTexture(tex);
 
    ret->video_image_viewer_.setSizePolicy(QSizePolicy::Preferred,
                                           QSizePolicy::Preferred);
    ret->video_image_viewer_.addAction(ui_->actionDelImage);
    ret->reader_mutex_.lock();
  }
  return ret;
}
 
MainWindow::RadarData* MainWindow::createRadarData(void) {
  RadarData* ret = new RadarData();
 
  if (ret) {
    int index = radarData_list_.count();
    QString radarName = tr("Radar%1").arg(index);
 
    ret->root_item_.setHidden(true);
    ret->root_item_.setText(0, radarName);
 
    ret->channel_name_item_.setText(0, "ChannelName");
    ret->action_item_.setText(0, "Action");
    ret->enable_checkBox_.setChecked(true);
 
    ret->action_item_button_.setText("Play");
    ret->action_item_button_.setCheckable(true);
    ret->action_item_button_.setStyleSheet(globalTreeItemStyle);
 
    ret->channel_name_combobox_.setObjectName(tr("comboBox%1").arg(index));
    ret->channel_name_combobox_.setStyleSheet(globalTreeItemStyle);
 
    ret->root_item_.addChild(&ret->channel_name_item_);
    ret->root_item_.addChild(&ret->action_item_);
    ret->reader_mutex_.lock();
  }
  return ret;
}
 
void MainWindow::EnableGrid(bool b) { grid_->set_is_renderable(b); }
 
void MainWindow::ActionAddGrid(void) {
  if (grid_shader_ == nullptr) {
    grid_shader_ = RenderableObject::CreateShaderProgram(tr(gridVertexPath),
                                                         tr(gridFragPath));
    if (grid_shader_ != nullptr) {
      ui_->sceneWidget->AddNewShaderProg("grid", grid_shader_);
    }
  }
 
  if (grid_root_item_ == nullptr) {
    QTreeWidgetItem* colorChild = nullptr;
    QTreeWidgetItem* cellCountChild = nullptr;
    QSpinBox* spinbox = nullptr;
 
    grid_ = new Grid(6);
    if (grid_ == nullptr) {
      goto _ret1;
    }
 
    if (grid_shader_ == nullptr) {
      goto _ret2;
    }
 
    enable_grid_checkBox_ = new QCheckBox(ui_->treeWidget);
    if (enable_grid_checkBox_ == nullptr) {
      goto _ret2;
    }
 
    grid_root_item_ = new QTreeWidgetItem(ui_->treeWidget);
    if (grid_root_item_ == nullptr) {
      goto _ret3;
    }
 
    colorChild = new QTreeWidgetItem(grid_root_item_);
    if (colorChild == nullptr) {
      goto _ret4;
    }
    grid_root_item_->addChild(colorChild);
    colorChild->setText(0, "Color");
    colorChild->setText(1, tr("%1;%2;%3")
                               .arg(grid_->red())
                               .arg(grid_->green())
                               .arg(grid_->blue()));
 
    spinbox = new QSpinBox(ui_->treeWidget);
    if (spinbox == nullptr) {
      goto _ret5;
    }
    spinbox->setMinimum(1);
    spinbox->setMaximum(100);
    spinbox->setSingleStep(1);
    spinbox->setValue(grid_->CellCount());
    spinbox->setStyleSheet(globalTreeItemStyle);
 
    cellCountChild = new QTreeWidgetItem(grid_root_item_);
    if (cellCountChild == nullptr) {
      goto _ret6;
    }
    grid_root_item_->addChild(cellCountChild);
    cellCountChild->setText(0, "CellCount");
 
    grid_->set_shader_program(grid_shader_);
    if (!ui_->sceneWidget->AddPermanentRenderObj(grid_)) {
      goto _ret7;
    }
 
    enable_grid_checkBox_->setText("Enable");
    enable_grid_checkBox_->setChecked(true);
    grid_root_item_->setText(0, "Grid");
    grid_root_item_->setText(1, "");
 
    ui_->treeWidget->addTopLevelItem(grid_root_item_);
 
    ui_->treeWidget->setItemWidget(grid_root_item_, 1, enable_grid_checkBox_);
    ui_->treeWidget->setItemWidget(cellCountChild, 1, spinbox);
 
    connect(enable_grid_checkBox_, SIGNAL(clicked(bool)), this,
            SLOT(EnableGrid(bool)));
    connect(ui_->treeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),
            this, SLOT(EditGridColor(QTreeWidgetItem*, int)));
    connect(spinbox, SIGNAL(valueChanged(int)), this,
            SLOT(ChangeGridCellCountBySize(int)));
    return;
 
  _ret7:
    delete cellCountChild;
  _ret6:
    delete spinbox;
  _ret5:
    delete colorChild;
  _ret4:
    delete grid_root_item_;
  _ret3:
    delete enable_grid_checkBox_;
  _ret2:
    delete grid_;
  _ret1:
    QMessageBox::warning(this, tr("Error"),
                         tr("There is no enough memory for creating Grid!!!"),
                         QMessageBox::Ok);
    return;
  }
}
 
void MainWindow::ChangeGridCellCountBySize(int v) {
  grid_->Destroy();
  grid_->set_shader_program(grid_shader_);
  grid_->SetCellCount(v);
  grid_->set_is_renderable(true);
}
 
void MainWindow::EditGridColor(QTreeWidgetItem* item, int column) {
  if (column && item != nullptr && grid_root_item_ != nullptr &&
      item == grid_root_item_->child(0)) {
    QStringList rgb = item->text(1).split(';');
    QColor color(rgb.at(0).toInt(), rgb.at(1).toInt(), rgb.at(2).toInt());
 
    color = QColorDialog::getColor(color, nullptr, tr("set grid color"));
 
    if (color.isValid()) {
      QString str =
          tr("%1;%2;%3").arg(color.red()).arg(color.green()).arg(color.blue());
      item->setText(1, str);
 
      grid_->set_grid_color(color);
    }
  }
}
 
void MainWindow::EnableRadarPoints(bool b) {
  QCheckBox* obj = static_cast<QCheckBox*>(sender());
  RadarData* r = StructPtrByMemberPtr(obj, RadarData, enable_checkBox_);
  ui_->sceneWidget->setTempObjGroupEnabled(r->root_item_.text(0).toStdString(),
                                           b);
}
 
void MainWindow::ActionOpenRadarChannel(void) {
  if (radar_points_shader_ == nullptr) {
    radar_points_shader_ = RenderableObject::CreateShaderProgram(
        tr(radarVertexPath), tr(radarFragPath));
    if (radar_points_shader_ != nullptr) {
      ui_->sceneWidget->AddNewShaderProg("radarpoints", radar_points_shader_);
    } else {
      QMessageBox::warning(
          this, tr("NO Shader"),
          tr("There is no suitable shader for Radar Points!!!"),
          QMessageBox::Ok);
      return;
    }
  }
 
  RadarData* radarProxy;
 
  if (closed_radarData_list_.empty()) {
    radarProxy = createRadarData();
 
    if (radarProxy == nullptr) {
      QMessageBox::warning(this, tr("No Enough Memory"),
                           tr("There is no enough memory!!!\nCannot add new "
                              "image or video channel!"),
                           QMessageBox::Ok);
      return;
    }
 
    ui_->treeWidget->addTopLevelItem(&radarProxy->root_item_);
    ui_->treeWidget->setItemWidget(&radarProxy->root_item_, 1,
                                   &radarProxy->enable_checkBox_);
 
    ui_->treeWidget->setItemWidget(&radarProxy->channel_name_item_, 1,
                                   &radarProxy->channel_name_combobox_);
    ui_->treeWidget->setItemWidget(&radarProxy->action_item_, 1,
                                   &radarProxy->action_item_button_);
 
    for (int i = 0; i < all_channel_root_->childCount(); ++i) {
      QTreeWidgetItem* child = all_channel_root_->child(i);
      QString channel = child->text(0);
      if (channel.contains("radar")) {
        radarProxy->channel_name_combobox_.addItem(channel);
      }
    }
  } else {
    radarProxy = closed_radarData_list_.takeFirst();
  }
 
  connect(&radarProxy->action_item_button_, SIGNAL(clicked(bool)), this,
          SLOT(openRadarChannel(bool)));
  connect(&radarProxy->enable_checkBox_, SIGNAL(clicked(bool)), this,
          SLOT(EnableRadarPoints(bool)));
  connect(&radarProxy->channel_name_combobox_, SIGNAL(currentIndexChanged(int)),
          this, SLOT(ChangeRadarChannel()));
 
  radarData_list_.append(radarProxy);
 
  radarProxy->root_item_.setHidden(false);
 
  ui_->treeWidget->setVisible(true);
  ui_->actionGlobal->setChecked(true);
}
 
void MainWindow::openRadarChannel(bool b) {
  QPushButton* obj = static_cast<QPushButton*>(QObject::sender());
  RadarData* theVideoImg =
      StructPtrByMemberPtr(obj, RadarData, action_item_button_);
  DoOpenRadarChannel(b, theVideoImg);
}
 
void MainWindow::DoOpenRadarChannel(bool b, RadarData* radarProxy) {
  if (b) {
    if (radarProxy->channel_name_combobox_.currentText().isEmpty()) {
      QMessageBox::warning(
          this, tr("Setup Channel Name"),
          tr("Channel Name cannot be empty!!!\nPlease select one!"),
          QMessageBox::Ok);
      radarProxy->action_item_button_.setChecked(false);
      return;
    }
 
    if (!radarProxy->channel_reader_) {
      radarProxy->channel_reader_ =
          new CyberChannReader<apollo::drivers::RadarObstacles>();
 
      if (!radarProxy->channel_reader_) {
        QMessageBox::warning(this, tr("Create cyber Channel Reader"),
                             tr("There is no enough memory!!!\nCannot create "
                                "cyber channel reader!"),
                             QMessageBox::Ok);
        return;
      }
 
      auto radarcallback =
          [this, radarProxy](
              const std::shared_ptr<apollo::drivers::RadarObstacles>& pdata) {
            this->RadarRenderCallback(pdata, radarProxy);
          };
 
      std::string nodeName("Visualizer-");
      nodeName.append(radarProxy->root_item_.text(0).toStdString());
 
      if (!radarProxy->channel_reader_->InstallCallbackAndOpen(
              radarcallback,
              radarProxy->channel_name_combobox_.currentText().toStdString(),
              nodeName)) {
        QMessageBox::warning(
            this, tr("Setup Channel Callback"),
            tr("Channel Callback cannot be installed!!!\nPlease check it!"),
            QMessageBox::Ok);
        delete radarProxy->channel_reader_;
        radarProxy->channel_reader_ = nullptr;
 
        radarProxy->action_item_button_.setChecked(false);
        return;
      }
    }
 
    radarProxy->root_item_.setToolTip(
        0, radarProxy->channel_name_combobox_.currentText());
 
    radarProxy->action_item_button_.setText("Stop");
    radarProxy->channel_name_combobox_.setEnabled(false);
 
    radarProxy->reader_mutex_.unlock();
  } else {
    if (!radarProxy->channel_name_combobox_.isEnabled()) {
      radarProxy->reader_mutex_.lock();
      radarProxy->action_item_button_.setText("Play");
      radarProxy->channel_name_combobox_.setEnabled(true);
    }
  }
  ui_->treeWidget->setCurrentItem(nullptr);
  ui_->treeWidget->clearFocus();
}
 
void MainWindow::RadarRenderCallback(
    const std::shared_ptr<const apollo::drivers::RadarObstacles>& rawData,
    RadarData* radar) {
  radar->reader_mutex_.lock();
  radar->reader_mutex_.unlock();
 
  std::cout << "-------MainWindow::RadarRenderCallback()-------" << std::endl;
 
  if (rawData != nullptr) {
    RadarPoints* r = new RadarPoints(radar_points_shader_);
    if (r) {
      if (!r->FillData(rawData) ||
          !ui_->sceneWidget->AddTempRenderableObj(
              radar->root_item_.text(0).toStdString(), r)) {
        delete r;
      }
    } else {
      std::cerr << "cannot create RadarPoints Renderable Object" << std::endl;
    }
  }
}
 
void MainWindow::ActionOpenPointCloud(void) {
  if (pointcloud_shader_ == nullptr) {
    pointcloud_shader_ =
        RenderableObject::CreateShaderProgram(tr(pcVertexPath), tr(pcFragPath));
    if (pointcloud_shader_ != nullptr) {
      ui_->sceneWidget->AddNewShaderProg("pointcloud", pointcloud_shader_);
    } else {
      QMessageBox::warning(this, tr("NO Shader"),
                           tr("There is no suitable shader for Pointcloud!!!"),
                           QMessageBox::Ok);
      return;
    }
  }
 
  if (pointcloud_top_item_ == nullptr) {
    pointcloud_top_item_ = new QTreeWidgetItem(ui_->treeWidget);
    if (pointcloud_top_item_ == nullptr) {
      return;
    }
 
    pointcloud_top_item_->setText(0, "PointCloud2");
    pointcloud_top_item_->setText(1, "");
 
    QTreeWidgetItem* item = new QTreeWidgetItem(pointcloud_top_item_);
    if (item == nullptr) {
      QMessageBox::warning(this, tr("NO Enough Memory"),
                           tr("Cannot create tree item for channel name!!!"),
                           QMessageBox::Ok);
      return;
    }
 
    item->setText(0, "ChannelName");
    ui_->treeWidget->setItemWidget(item, 1, pointcloud_comboBox_);
 
    item = new QTreeWidgetItem(pointcloud_top_item_);
    if (item == nullptr) {
      QMessageBox::warning(this, tr("NO Enough Memory"),
                           tr("Cannot create tree item for channel Action!!!"),
                           QMessageBox::Ok);
      return;
    }
 
    item->setText(0, "Action");
 
    pointcloud_button_->setText("Play");
    ui_->treeWidget->setItemWidget(item, 1, pointcloud_button_);
 
    ui_->treeWidget->setVisible(true);
    ui_->actionGlobal->setChecked(true);
  }
}
 
void MainWindow::ActionOpenImages(void) {
  if (open_images_dialog_ == nullptr) {
    open_images_dialog_ = new VideoImagesDialog(this);
    if (open_images_dialog_ == nullptr) {
      QMessageBox::warning(this, tr("No Enough Memory"),
                           tr("There is no enough memory!!!"), QMessageBox::Ok);
      return;
    } else {
      connect(open_images_dialog_, SIGNAL(accepted()), this,
              SLOT(AddVideoImages()));
    }
  }
 
  open_images_dialog_->show();
}
 
void MainWindow::AddVideoImages(void) {
  int count = open_images_dialog_->count();
  while (count) {
    ActionOpenImage();
    --count;
  }
}
 
void MainWindow::ActionOpenImage(void) {
  VideoImgProxy* videoImgProxy;
 
  if (closed_video_image_viewer_list_.empty()) {
    videoImgProxy = AddVideoImgViewer();
 
    if (videoImgProxy == nullptr) {
      QMessageBox::warning(this, tr("No Enough Memory"),
                           tr("There is no enough memory!!!\nCannot add new "
                              "image or video channel!"),
                           QMessageBox::Ok);
      return;
    }
 
    videoImgProxy->video_image_viewer_.setParent(ui_->videoImageWidget);
 
    ui_->treeWidget->addTopLevelItem(&videoImgProxy->root_item_);
    ui_->treeWidget->setItemWidget(&videoImgProxy->channel_name_item_, 1,
                                   &videoImgProxy->channel_name_combobox_);
    ui_->treeWidget->setItemWidget(&videoImgProxy->action_item_, 1,
                                   &videoImgProxy->action_item_button_);
 
    for (int i = 0; i < all_channel_root_->childCount(); ++i) {
      QTreeWidgetItem* child = all_channel_root_->child(i);
      QString channel = child->text(0);
      if (channel.contains("camera")) {
        videoImgProxy->channel_name_combobox_.addItem(channel);
      }
    }
  } else {
    videoImgProxy = closed_video_image_viewer_list_.takeFirst();
  }
 
  connect(&videoImgProxy->action_item_button_, SIGNAL(clicked(bool)), this,
          SLOT(PlayVideoImage(bool)));
  connect(&videoImgProxy->channel_name_combobox_,
          SIGNAL(currentIndexChanged(int)), this,
          SLOT(ChangeVideoImgChannel()));
  connect(&videoImgProxy->video_image_viewer_,
          SIGNAL(focusOnThis(FixedAspectRatioWidget*)), this,
          SLOT(SelectCurrentTreeItem(FixedAspectRatioWidget*)));
 
  video_image_viewer_list_.append(videoImgProxy);
  videoImgProxy->video_image_viewer_.setVisible(true);
 
  calculateWH();
 
  videoImgProxy->video_image_viewer_.StartOrStopUpdate(true);
  videoImgProxy->root_item_.setHidden(false);
 
  ui_->videoImageWidget->setVisible(true);
 
  ui_->treeWidget->setVisible(true);
  ui_->actionGlobal->setChecked(true);
 
  repaint();
}
 
void MainWindow::ActionDelVideoImage(void) {
  QTreeWidgetItem* topItem = ui_->treeWidget->currentItem();
  VideoImgProxy* proxy =
      StructPtrByMemberPtr(topItem, VideoImgProxy, root_item_);
 
  DoDeleteVideoImg(proxy);
  ui_->actionDelImage->setEnabled(false);
}
 
void MainWindow::CloseVideoImgViewer(bool b) {
  if (!b) {
    VideoImgViewer* dock = static_cast<VideoImgViewer*>(sender());
    DoDeleteVideoImg(
        StructPtrByMemberPtr(dock, VideoImgProxy, video_image_viewer_));
  }
}
 
void MainWindow::DoDeleteVideoImg(VideoImgProxy* proxy) {
  disconnect(&proxy->action_item_button_, SIGNAL(clicked(bool)), this,
             SLOT(PlayVideoImage(bool)));
  disconnect(&proxy->channel_name_combobox_, SIGNAL(currentIndexChanged(int)),
             this, SLOT(ChangeVideoImgChannel()));
  disconnect(&proxy->video_image_viewer_,
             SIGNAL(focusOnThis(FixedAspectRatioWidget*)), this,
             SLOT(SelectCurrentTreeItem(FixedAspectRatioWidget*)));
 
  proxy->action_item_button_.setChecked(false);
  DoPlayVideoImage(false, proxy);
 
  proxy->video_image_viewer_.StartOrStopUpdate(false);
  proxy->root_item_.setHidden(true);
  proxy->video_image_viewer_.setVisible(false);
  ui_->videoImageGridLayout->removeWidget(&proxy->video_image_viewer_);
 
  video_image_viewer_list_.removeOne(proxy);
  closed_video_image_viewer_list_.append(proxy);
 
  if (video_image_viewer_list_.count()) {
    calculateWH();
  } else {
    ui_->videoImageWidget->setVisible(false);
  }
}
 
void MainWindow::UpdateActions(void) {
  QTreeWidgetItem* item = ui_->treeWidget->currentItem();
  ui_->actionDelImage->setEnabled(false);
  if (item) {
    if (!item->parent() && item != pointcloud_top_item_ &&
        item != all_channel_root_ && item != grid_root_item_) {
      ui_->actionDelImage->setEnabled(true);
    }
  }
}
 
void MainWindow::PointCloudReaderCallback(
    const std::shared_ptr<const apollo::drivers::PointCloud>& pdata) {
  pointcloud_reader_mutex_.lock();
  pointcloud_reader_mutex_.unlock();
  PointCloud* pc = new PointCloud(pdata->point_size(), 4, pointcloud_shader_);
  if (pc) {
    if (!pc->FillData(pdata) ||
        !ui_->sceneWidget->AddTempRenderableObj(pcTempObjGroupName, pc)) {
      delete pc;
    }
  } else {
    std::cerr << "-----Cannot create PointCloud----------" << std::endl;
  }
}
 
void MainWindow::PlayRenderableObject(bool b) {
  if (b) {
    if (pointcloud_comboBox_->currentText().isEmpty()) {
      QMessageBox::warning(
          this, tr("Setup Channel Name"),
          tr("Channel Name cannot be empty!!!\nPlease Select it!"),
          QMessageBox::Ok);
      pointcloud_button_->setChecked(false);
      return;
    }
 
    if (!pointcloud_channel_Reader_) {
      pointcloud_channel_Reader_ =
          new CyberChannReader<apollo::drivers::PointCloud>();
 
      if (!pointcloud_channel_Reader_) {
        QMessageBox::warning(this, tr("Create Cyber Channel Reader"),
                             tr("There is no enough memory!!!\nCannot create "
                                "cyber channel reader!"),
                             QMessageBox::Ok);
        pointcloud_button_->setChecked(false);
        return;
      }
 
      auto pointCallback =
          [this](const std::shared_ptr<apollo::drivers::PointCloud>& pdata) {
            this->PointCloudReaderCallback(pdata);
          };
      std::string nodeName("Visualizer-");
      nodeName.append(pointcloud_top_item_->text(0).toStdString());
      if (!pointcloud_channel_Reader_->InstallCallbackAndOpen(
              pointCallback, pointcloud_comboBox_->currentText().toStdString(),
              nodeName)) {
        QMessageBox::warning(
            this, tr("Setup Channel Callback"),
            tr("Channel Callback cannot be installed!!!\nPlease check it!"),
            QMessageBox::Ok);
        delete pointcloud_channel_Reader_;
        pointcloud_channel_Reader_ = nullptr;
 
        pointcloud_button_->setChecked(false);
        return;
      }
    }
 
    ui_->sceneWidget->setToolTip(pointcloud_comboBox_->currentText());
    pointcloud_top_item_->setToolTip(0, pointcloud_comboBox_->currentText());
    pointcloud_comboBox_->setEnabled(false);
    pointcloud_button_->setText(tr("Stop"));
 
    pointcloud_reader_mutex_.unlock();
  } else {
    if (!pointcloud_comboBox_->isEnabled()) {
      pointcloud_reader_mutex_.lock();
      pointcloud_comboBox_->setEnabled(true);
      pointcloud_button_->setText(tr("Show"));
    }
  }
 
  ui_->treeWidget->setCurrentItem(nullptr);
  ui_->treeWidget->clearFocus();
}
 
void MainWindow::ImageReaderCallback(
    const std::shared_ptr<const apollo::drivers::Image>& imgData,
    VideoImgProxy* theVideoImgProxy) {
  theVideoImgProxy->reader_mutex_.lock();
  if (theVideoImgProxy->dynamic_texture_ != nullptr && imgData != nullptr) {
    if (theVideoImgProxy->dynamic_texture_->UpdateData(imgData)) {
      theVideoImgProxy->video_image_viewer_.SetupDynamicTexture(
          theVideoImgProxy->dynamic_texture_);
    } else {
      std::cerr << "--------Cannot update dynamic Texture Data--------"
                << std::endl;
    }
  } else {
    std::cerr
        << "----Dynamic Texture is nullptr or apollo.drivers.Image is nullptr"
        << std::endl;
  }
  theVideoImgProxy->reader_mutex_.unlock();
}
 
void MainWindow::ImageReaderCallback(
    const std::shared_ptr<const apollo::drivers::CompressedImage>& imgData,
    VideoImgProxy* theVideoImgProxy) {
  theVideoImgProxy->reader_mutex_.lock();
  if (theVideoImgProxy->dynamic_texture_ != nullptr && imgData != nullptr) {
    QImage img;
    const std::string& data = imgData->data();
    if (img.loadFromData(reinterpret_cast<const unsigned char*>(data.c_str()),
                         static_cast<int>(data.size()))) {
      if (theVideoImgProxy->dynamic_texture_->UpdateData(img)) {
        theVideoImgProxy->video_image_viewer_.SetupDynamicTexture(
            theVideoImgProxy->dynamic_texture_);
      } else {
        std::cerr << "--------Cannot update dynamic Texture Data--------"
                  << std::endl;
      }
    } else {
      std::cerr
          << "-----------Cannot load compressed image from data with QImage"
          << std::endl;
    }
  } else {
    std::cerr
        << "----Dynamic Texture is nullptr or apollo.drivers.Image is nullptr"
        << std::endl;
  }
  theVideoImgProxy->reader_mutex_.unlock();
}
 
void MainWindow::PlayVideoImage(bool b) {
  QPushButton* obj = static_cast<QPushButton*>(QObject::sender());
  VideoImgProxy* theVideoImg =
      StructPtrByMemberPtr(obj, VideoImgProxy, action_item_button_);
  DoPlayVideoImage(b, theVideoImg);
}
 
void MainWindow::DoPlayVideoImage(bool b, VideoImgProxy* theVideoImg) {
  if (b) {
    if (theVideoImg->channel_name_combobox_.currentText().isEmpty()) {
      QMessageBox::warning(
          this, tr("Setup Channel Name"),
          tr("Channel Name cannot be empty!!!\nPlease select one!"),
          QMessageBox::Ok);
      theVideoImg->action_item_button_.setChecked(false);
      return;
    }
 
    const std::string channelName =
        theVideoImg->channel_name_combobox_.currentText().toStdString();
    if (_channelName2TypeMap[channelName] == CompressedImageType)
      theVideoImg->isCompressedImage_ = true;
 
    if (!theVideoImg->image_reader_) {
      if (theVideoImg->isCompressedImage_) {
        theVideoImg->compressed_image_reader_ =
            new CyberChannReader<apollo::drivers::CompressedImage>();
      } else {
        theVideoImg->image_reader_ =
            new CyberChannReader<apollo::drivers::Image>();
      }
 
      if (!theVideoImg->image_reader_) {
        QMessageBox::warning(this, tr("Create cyber Channel Reader"),
                             tr("There is no enough memory!!!\nCannot create "
                                "cyber channel reader!"),
                             QMessageBox::Ok);
        return;
      }
 
      std::string nodeName("Visualizer-");
      nodeName.append(theVideoImg->root_item_.text(0).toStdString());
 
      bool ret = false;
 
      if (theVideoImg->isCompressedImage_) {
        auto videoCallback =
            [this, theVideoImg](
                const std::shared_ptr<apollo::drivers::CompressedImage>&
                    pdata) { this->ImageReaderCallback(pdata, theVideoImg); };
 
        ret = theVideoImg->compressed_image_reader_->InstallCallbackAndOpen(
            videoCallback, channelName, nodeName);
      } else {
        auto videoCallback =
            [this, theVideoImg](
                const std::shared_ptr<apollo::drivers::Image>& pdata) {
              this->ImageReaderCallback(pdata, theVideoImg);
            };
        ret = theVideoImg->image_reader_->InstallCallbackAndOpen(
            videoCallback, channelName, nodeName);
      }
      if (!ret) {
        QMessageBox::warning(
            this, tr("Setup Channel Callback"),
            tr("Channel Callback cannot be installed!!!\nPlease check it!"),
            QMessageBox::Ok);
 
        theVideoImg->deleteReader();
        theVideoImg->action_item_button_.setChecked(false);
        return;
      }
    }
 
    theVideoImg->root_item_.setToolTip(
        0, theVideoImg->channel_name_combobox_.currentText());
    theVideoImg->video_image_viewer_.setToolTip(
        theVideoImg->channel_name_combobox_.currentText());
 
    theVideoImg->action_item_button_.setText("Stop");
    theVideoImg->channel_name_combobox_.setEnabled(false);
 
    theVideoImg->reader_mutex_.unlock();
  } else {
    if (!theVideoImg->channel_name_combobox_.isEnabled()) {
      theVideoImg->reader_mutex_.lock();
      theVideoImg->action_item_button_.setText("Play");
      theVideoImg->channel_name_combobox_.setEnabled(true);
    }
  }
  ui_->treeWidget->setCurrentItem(nullptr);
  ui_->treeWidget->clearFocus();
}
 
void MainWindow::ChangePointCloudChannel() {
  if (pointcloud_channel_Reader_ != nullptr) {
    pointcloud_channel_Reader_->CloseChannel();
    std::string nodeName("Visualizer-");
    nodeName.append(pointcloud_top_item_->text(0).toStdString());
    pointcloud_channel_Reader_->OpenChannel(
        pointcloud_comboBox_->currentText().toStdString(), nodeName);
  }
}
 
void MainWindow::ChangeVideoImgChannel() {
  QComboBox* obj = static_cast<QComboBox*>(QObject::sender());
  VideoImgProxy* theVideoImg =
      StructPtrByMemberPtr(obj, VideoImgProxy, channel_name_combobox_);
 
  if (theVideoImg->image_reader_ != nullptr) {
    theVideoImg->deleteReader();
  }
}
 
void MainWindow::ChangeRadarChannel(void) {
  QComboBox* obj = static_cast<QComboBox*>(QObject::sender());
  RadarData* radar =
      StructPtrByMemberPtr(obj, RadarData, channel_name_combobox_);
 
  if (radar->channel_reader_ != nullptr) {
    radar->channel_reader_->CloseChannel();
    std::string nodeName("Visualizer-");
    nodeName.append(radar->root_item_.text(0).toStdString());
    radar->channel_reader_->OpenChannel(obj->currentText().toStdString(),
                                        nodeName);
  }
}
 
void MainWindow::SelectCurrentTreeItem(FixedAspectRatioWidget* dock) {
  if (dock) {
    VideoImgProxy* theVideoImg =
        StructPtrByMemberPtr(dock, VideoImgProxy, video_image_viewer_);
    theVideoImg->root_item_.setExpanded(true);
    if (ui_->treeWidget->currentItem() == &theVideoImg->root_item_) {
      ui_->actionDelImage->setEnabled(true);
    } else {
      ui_->treeWidget->setCurrentItem(&theVideoImg->root_item_);
    }
    ui_->treeWidget->setFocus();
  }
}
 
void MainWindow::TopologyChanged(
    const apollo::cyber::proto::ChangeMsg& changeMsg) {
  if (apollo::cyber::proto::ChangeType::CHANGE_CHANNEL ==
          changeMsg.change_type() &&
      apollo::cyber::proto::RoleType::ROLE_WRITER == changeMsg.role_type() &&
      apollo::cyber::proto::OperateType::OPT_JOIN == changeMsg.operate_type()) {
    AddNewWriter(changeMsg.role_attr());
  }
}
 
void MainWindow::AddNewWriter(
    const apollo::cyber::proto::RoleAttributes& role) {
  const std::string& channelName = role.channel_name();
  if (_channelName2TypeMap.find(channelName) != _channelName2TypeMap.end()) {
    return;
  }
  const std::string& msgTypeName = role.message_type();
  _channelName2TypeMap[channelName] = msgTypeName;
 
  QTreeWidgetItem* child = new QTreeWidgetItem();
  if (child == nullptr) {
    QMessageBox::warning(this, tr("Error"), tr("No Enough for New Channel!!!"),
                         QMessageBox::Ok);
    return;
  }
 
  QString str(channelName.c_str());
  child->setText(0, str);
  child->setToolTip(0, str);
 
  bool b = true;
  for (int i = 0; i < all_channel_root_->childCount(); ++i) {
    if (str < all_channel_root_->child(i)->text(0)) {
      all_channel_root_->insertChild(i, child);
      b = false;
    }
  }
 
  if (b) {
    all_channel_root_->addChild(child);
  }
  ui_->treeWidget->setRootIsDecorated(true);
 
  QString msgType(msgTypeName.c_str());
  if (msgType.contains("camera", Qt::CaseInsensitive)) {
    for (VideoImgProxy* item : video_image_viewer_list_) {
      item->channel_name_combobox_.addItem(str);
    }
 
    for (VideoImgProxy* item : closed_video_image_viewer_list_) {
      item->channel_name_combobox_.addItem(str);
    }
  }
 
  if (msgType.contains("pointcloud", Qt::CaseInsensitive)) {
    pointcloud_comboBox_->addItem(str);
  }
 
  if (msgType.contains("radar", Qt::CaseInsensitive)) {
    for (RadarData* item : radarData_list_) {
      item->channel_name_combobox_.addItem(str);
    }
 
    for (RadarData* item : closed_radarData_list_) {
      item->channel_name_combobox_.addItem(str);
    }
  }
}
 
void MainWindow::PlayPause(void) {
  QObject* obj = QObject::sender();
  bool b = true;
  if (obj == ui_->actionPause) {
    b = false;
  }
  if (pointcloud_top_item_) {
    pointcloud_button_->setChecked(b);
    PlayRenderableObject(b);
  }
  for (VideoImgProxy* p : video_image_viewer_list_) {
    p->action_item_button_.setChecked(b);
    DoPlayVideoImage(b, p);
  }
  for (RadarData* item : radarData_list_) {
    item->action_item_button_.setChecked(b);
    DoOpenRadarChannel(b, item);
  }
}
 
void MainWindow::resizeEvent(QResizeEvent* event) {
  QMainWindow::resizeEvent(event);
  calculateWH();
}
 
void MainWindow::showMessage() {
  QObject* obj = QObject::sender();
 
  if (obj == ui_->actionAbout) {
    msg_dialog_->setWindowTitle(tr("About"));
    msg_dialog_->setMessage(aboutMessage);
    goto showMsgLabel;
  }
 
  if (obj == ui_->actionLicense) {
    msg_dialog_->setWindowTitle(tr("License"));
    msg_dialog_->setMessage(licenseMessage);
 
  showMsgLabel:
    msg_dialog_->adjustSize();
    msg_dialog_->show();
  }
}

StructPtrByMemberPtr

#define StructPtrByMemberPtr	(		MemberPtr,
			StructType,
			Member
	)

值:

  reinterpret_cast<StructType*>(reinterpret_cast<char*>(MemberPtr) - \
                                MEMBER_OFFSET(StructType, Member))

在文件 main_window.cc 第 76 行定义.