graph_viewer_gui_controller.cpp

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#include "graph_viewer_gui_controller.h"
 
#include <Dxlib.h>
 
#include <magic_enum.hpp>
#include <string>
 
#include "graphic_const.h"
#include "keyboard.h"
#include "leg_state.h"
 
namespace designlab {
 
GraphViewerGUIController::GraphViewerGUIController(
    const std::vector<RobotStateNode>* const p_graph,
    size_t* const p_display_node_index,
    const std::shared_ptr<const ApplicationSettingRecord>& setting_ptr)
    : graph_ptr_(p_graph),
      display_node_index_ptr_(p_display_node_index),
      setting_ptr_(setting_ptr) {}
 
void GraphViewerGUIController::Update() {
  InputNumber();
  UpdateChildrenList();
  ChangeDisplayNodeIndex();
 
  keyboard_.Update();
}
 
void GraphViewerGUIController::Draw() const {
  DrawGraphData();
  DrawNodeControlPanel();
 
  if (graph_ptr_->size() != 0 &&
      *display_node_index_ptr_ < graph_ptr_->size()) {
    // DrawNodeData(graph_ptr_->at(*display_node_index_ptr_));
  }
}
 
void GraphViewerGUIController::DrawGraphData() const {
  const int kBoxSizeX = 250;
  const int kBoxSizeY = 200;
  const int kBoxMinX = setting_ptr_->window_size_x - kBoxSizeX - 10;
  const int kBoxMinY = setting_ptr_->window_size_y - kBoxSizeY - 10;
  const unsigned int kBaseColor = GetColor(255, 255, 255);
 
  // 枠
  SetDrawBlendMode(DX_BLENDMODE_ALPHA, 128);
  DrawBox(kBoxMinX, kBoxMinY, kBoxMinX + kBoxSizeX, kBoxMinY + kBoxSizeY,
          kBaseColor, TRUE);
  SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 0);
 
  const unsigned int kTextColor = GetColor(10, 10, 10);
 
  // テキスト
  if (graph_ptr_->size() == 0) {
    DrawString(kBoxMinX + 10, kBoxMinY + 10, "ノード数 : 0", kTextColor);
    DrawString(kBoxMinX + 10, kBoxMinY + 30, "グラフを生成してください",
               kTextColor);
  } else {
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 10, kTextColor, "総ノード数:%d",
                     graph_ptr_->size());
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 30, kTextColor,
                     "表示ノード:%d番", *display_node_index_ptr_);
 
    // 深さごとのノードの数.
    for (size_t i = 0; i < graph_node_depth_data_.size(); i++) {
      DrawFormatString(kBoxMinX + 10, kBoxMinY + 50 + 20 * static_cast<int>(i),
                       kTextColor, "　(深さ%dのノード:%d)", static_cast<int>(i),
                       static_cast<int>(graph_node_depth_data_.at(i)));
    }
  }
}
 
void GraphViewerGUIController::DrawNodeControlPanel() const {
  const int kBoxSizeX = 350;
  const int kBoxSizeY = 250;
  const int kBoxMinX = 10;
  const int kBoxMinY = 10;
  const unsigned int kBaseColor = GetColor(255, 255, 255);
 
  // 枠
  SetDrawBlendMode(DX_BLENDMODE_ALPHA, 128);
  DrawBox(kBoxMinX, kBoxMinY, kBoxMinX + kBoxSizeX, kBoxMinY + kBoxSizeY,
          kBaseColor, TRUE);
  SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 0);
 
  const unsigned int kTextColor = GetColor(10, 10, 10);
 
  // テキスト
  DrawFormatString(kBoxMinX + 10, kBoxMinY + 10, kTextColor,
                   "input ( C でクリア)");
 
  if (input_number_ < 0) {
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 30, kTextColor,
                     "　数字を入力してください");
  } else {
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 30, kTextColor, "　%d",
                     input_number_);
  }
 
  if (graph_ptr_->size() > *display_node_index_ptr_) {
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 60, kTextColor,
                     "%d番ノードの親ノード:%d番", *display_node_index_ptr_,
                     graph_ptr_->at(*display_node_index_ptr_).parent_index);
 
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 90, kTextColor,
                     "%d番ノードの子ノード数:%d個", children_list_.first,
                     children_list_.second.size());
 
    std::string str = children_list_.second.size() == 0 ? "None" : "　";
 
    for (size_t i = 0; i < children_list_.second.size(); i++) {
      if (i > (size_t)6 * 5 - 1) {
        str += "...";
        break;
      }
 
      str += std::to_string(children_list_.second.at(i)) + ",";
 
      if (i % 6 == 0 && i != 0) {
        str += "\n　";
      }
    }
 
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 110, kTextColor,
                     "%d番ノードの子ノードリスト", children_list_.first);
    DrawFormatString(kBoxMinX + 10, kBoxMinY + 130, kTextColor, str.c_str());
  }
}
 
void GraphViewerGUIController::DrawNodeData(const RobotStateNode& node) const {
  using leg_func::GetDiscreteComPos;
  using leg_func::GetDiscreteLegPos;
 
  const int kBoxSizeX = 400;
  const int KBoxSizeY = 300;
  const int kBoxMinX = setting_ptr_->window_size_x - 25 - kBoxSizeX;
  const int kBoxMinY = 25;
  const unsigned int kBoxColor = GetColor(255, 255, 255);
  const unsigned int kBoxAlpha = 128;
 
  // 枠.
  SetDrawBlendMode(DX_BLENDMODE_ALPHA, kBoxAlpha);
 
  DrawBox(kBoxMinX, kBoxMinY, kBoxMinX + kBoxSizeX, kBoxMinY + KBoxSizeY,
          kBoxColor, TRUE);
 
  SetDrawBlendMode(DX_BLENDMODE_NOBLEND, 0);
 
  // テキスト.
  const unsigned int kTextColor = GetColor(10, 10, 10);
  const int kTextXPos = kBoxMinX + 10;
  const int kTextYMinPos = kBoxMinY + 10;
  const int kTextYInterval = 30;
 
  int text_line = 0;
 
  DrawFormatString(kTextXPos, kTextYMinPos + kTextYInterval * (text_line++),
                   kTextColor, "重心：%d,脚位置：%d,%d,%d,%d,%d,%d",
                   GetDiscreteComPos(node.leg_state),
                   GetDiscreteLegPos(node.leg_state, 0),
                   GetDiscreteLegPos(node.leg_state, 1),
                   GetDiscreteLegPos(node.leg_state, 2),
                   GetDiscreteLegPos(node.leg_state, 3),
                   GetDiscreteLegPos(node.leg_state, 4),
                   GetDiscreteLegPos(node.leg_state, 5));
 
  // 重心を表示する.
  DrawFormatString(
      kTextXPos, kTextYMinPos + kTextYInterval * (text_line++), kTextColor,
      "重心位置(x:%5.3f,y:%5.3f,z:%5.3f)", node.center_of_mass_global_coord.x,
      node.center_of_mass_global_coord.y, node.center_of_mass_global_coord.z);
 
  // 遊脚か接地脚か.
  std::string str = "";
  for (int i = 0; i < HexapodConst::kLegNum; i++) {
    if (leg_func::IsGrounded(node.leg_state, i)) {
      str += "接地,";
    } else {
      str += "遊脚,";
    }
  }
 
  DrawFormatString(kTextXPos, kTextYMinPos + kTextYInterval * (text_line++),
                   kTextColor, "脚の状態：%s", str.c_str());
 
  // 脚の位置を表示する.
  for (int i = 0; i < HexapodConst::kLegNum; i++) {
    DrawFormatString(kTextXPos, kTextYMinPos + kTextYInterval * (text_line++),
                     kTextColor, "%d番脚の位置(x:%5.3f,y:%5.3f,z:%5.3f)", i,
                     node.leg_pos[i].x, node.leg_pos[i].y, node.leg_pos[i].z);
  }
 
  // 深さと次の動作を表示する.
  DrawFormatString(
      kTextXPos, kTextYMinPos + kTextYInterval * (text_line++), kTextColor,
      "深さ：%d, 次の動作 : %s", node.depth,
      static_cast<std::string>(magic_enum::enum_name(node.next_move)).c_str());
}
 
void GraphViewerGUIController::InputNumber() {
  // Cキーでリセット.
  if (keyboard_.GetPressingCount(KEY_INPUT_C) == 1) {
    input_number_ = -1;
    return;
  }
 
  // 数字入力.
  int input_number = -1;
 
  if (keyboard_.GetPressingCount(KEY_INPUT_0) == 1) {
    input_number = 0;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_1) == 1) {
    input_number = 1;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_2) == 1) {
    input_number = 2;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_3) == 1) {
    input_number = 3;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_4) == 1) {
    input_number = 4;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_5) == 1) {
    input_number = 5;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_6) == 1) {
    input_number = 6;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_7) == 1) {
    input_number = 7;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_8) == 1) {
    input_number = 8;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_9) == 1) {
    input_number = 9;
  }
 
  if (input_number >= 0) {
    if (input_number_ < 0) {
      input_number_ = input_number;
    } else {
      input_number_ *= 10;
      input_number_ += input_number;
    }
  }
}
 
void GraphViewerGUIController::ChangeDisplayNodeIndex() {
  if (graph_ptr_->size() == 0) {
    return;
  }
 
  if (keyboard_.GetPressingCount(KEY_INPUT_DOWN) == 1) {
    (*display_node_index_ptr_)--;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_UP) == 1) {
    (*display_node_index_ptr_)++;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_RETURN) == 1) {
    (*display_node_index_ptr_) = input_number_;
    input_number_ = -1;
  } else if (keyboard_.GetPressingCount(KEY_INPUT_P) == 1) {
    if (graph_ptr_->size() > *display_node_index_ptr_) {
      (*display_node_index_ptr_) =
          graph_ptr_->at(*display_node_index_ptr_).parent_index;
    }
  } else if (keyboard_.GetPressingCount(KEY_INPUT_LEFT) == 1 &&
             !children_list_.second.empty()) {
    display_children_list_index_--;
 
    if (display_children_list_index_ < 0) {
      display_children_list_index_ =
          static_cast<int>(children_list_.second.size()) - 1;
    }
 
    display_children_list_index_ =
        (display_children_list_index_ < 0) ? 0 : display_children_list_index_;
 
    (*display_node_index_ptr_) =
        children_list_.second.at(display_children_list_index_);
  } else if (keyboard_.GetPressingCount(KEY_INPUT_RIGHT) == 1 &&
             !children_list_.second.empty()) {
    display_children_list_index_++;
 
    if (display_children_list_index_ >= children_list_.second.size()) {
      display_children_list_index_ = 0;
    }
 
    (*display_node_index_ptr_) =
        children_list_.second.at(display_children_list_index_);
  }
 
  if (*display_node_index_ptr_ < 0) {
    *display_node_index_ptr_ = graph_ptr_->size() - 1;
  } else if (*display_node_index_ptr_ >= graph_ptr_->size()) {
    *display_node_index_ptr_ = 0;
  }
}
 
void GraphViewerGUIController::UpdateChildrenList() {
  if (graph_ptr_->size() == 0) {
    return;
  }
 
  if (keyboard_.GetPressingCount(KEY_INPUT_U) == 1) {
    children_list_.first = static_cast<int>(*display_node_index_ptr_);
    children_list_.second.clear();
 
    const size_t kGraphSize = graph_ptr_->size();
 
    for (size_t i = 0; i < kGraphSize; i++) {
      if (graph_ptr_->at(i).parent_index == children_list_.first) {
        children_list_.second.push_back(static_cast<int>(i));
      }
    }
  }
}
 
void GraphViewerGUIController::UpdateGraphNodeDepthData() {
  graph_node_depth_data_.clear();
  constexpr size_t kMaxDepth = 5;
 
  if (graph_ptr_->size() > 0) {
    graph_node_depth_data_.resize(kMaxDepth + 1);
 
    for (size_t i = 0; i < graph_ptr_->size(); ++i) {
      const auto index = static_cast<size_t>(graph_ptr_->at(i).depth);
      graph_node_depth_data_.at(index)++;
    }
  }
}
 
}  // namespace designlab