回転を含む外接矩形を抽出して対象ワークを認識する【道具としての OpenCV 画像認識】

# 本記事でできること
元画像
![rotated_rect_sample.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/37698/00381413-250a-6558-92af-aaab00d46a83.png)



かたまりを矩形で囲んで描画した画像
![Screenshot from 2024-03-10 16-22-05.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/37698/e7d42859-9a0d-8eef-c5e8-939ded535e9b.png)

# 想定シーン
## ロボットをビジュアルフィードバック制御する
カメラを使ったロボットアームの制御方法を、ビジュアルフィードバック制御といいます。ここでは、ビジュアルフィードバック制御を使った自動化システムを開発する際に必要となる画像認識プログラムをまとめています。

## 回転を含む外接矩形を抽出して対象ワークを認識する
画像処理フィルターをかけて、認識対象物体を抽出することができたら、次はその対象物体の位置が画像座標内のどこにあって、どのくらいの大きさで、どの角度で見えているのかということを計測したいと思います。本記事では、抽出された対象物体を囲む、回転を含む矩形（＝外接回転矩形）を描くプログラムを掲載します。

# 実行環境
- OS：Ubuntu 22.04 LTS
- 言語：C++
- クルーボ：v5.1.0

## クルーボについて
ロボットアプリケーション開発には、株式会社チトセロボティクスのロボット制御ソフトウェア「クルーボ」を使用します。本記事のプログラムは、クルーボがインストールされた制御コンピュータ上で動作します。

- クルーボの製品サイト：https://chitose-robotics.com/

## プログラム抜粋
```c++
std::optional<std::vector<cv::RotatedRect>> get_rotated_rects(const cv::Mat& image) {
    std::vector<std::vector<cv::Point>> contours;
    cv::Mat gray_image = convert_grayscale(image);
    cv::findContours(gray_image, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    cv::Mat input_points;
    std::vector<cv::RotatedRect> rotated_rects;
    bool target_is_found = false;
    for (size_t i = 0; i < contours.size(); i++) {
        if (contours[i].size() > 0) {
            cv::Mat(contours[i]).convertTo(input_points, CV_32F);
            cv::RotatedRect result_rotated_rect = cv::minAreaRect(input_points);
            rotated_rects.push_back(result_rotated_rect);
            target_is_found = true;
        }
    }
    if (target_is_found == false) {
        return std::nullopt;
    }
    return rotated_rects;
}
```

## 全体プログラム
```c++
#include <iostream>
#include <opencv2/opencv.hpp>
#include <optional>

cv::Mat load_image(const std::string file_path) {
    cv::Mat loaded_image = cv::imread(file_path, 1);
    if (loaded_image.empty()) {
        throw std::runtime_error("画像を正常に読み込めませんでした。");
    }
    return loaded_image;
}

cv::Mat convert_grayscale(const cv::Mat& image) {
    const int grayscale_channel_num = 1;
    if (image.channels() == grayscale_channel_num) {
        return image.clone();
    }
    cv::Mat gray_image;
    cvtColor(image, gray_image, cv::COLOR_BGR2GRAY);
    return gray_image;
}

cv::Mat convert_colorimage(const cv::Mat& image) {
    const int colorimage_channel_num = 3;
    if (image.channels() == colorimage_channel_num) {
        return image.clone();
    }
    cv::Mat color_image;
    cvtColor(image, color_image, cv::COLOR_GRAY2BGR);
    return color_image;
}

cv::Mat binary(const cv::Mat& image, const int threthold) {
    cv::Mat image_gray = convert_grayscale(image);
    cv::Mat binary_image;
    if (threthold == 0) {
        threshold(image_gray, binary_image, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
    } else {
        threshold(image_gray, binary_image, threthold, 255, cv::THRESH_BINARY);
    }
    return binary_image;
}

std::optional<std::vector<cv::RotatedRect>> get_rotated_rects(const cv::Mat& image) {
    std::vector<std::vector<cv::Point>> contours;
    cv::Mat gray_image = convert_grayscale(image);
    cv::findContours(gray_image, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    cv::Mat input_points;
    std::vector<cv::RotatedRect> rotated_rects;
    bool target_is_found = false;
    for (size_t i = 0; i < contours.size(); i++) {
        if (contours[i].size() > 0) {
            cv::Mat(contours[i]).convertTo(input_points, CV_32F);
            cv::RotatedRect result_rotated_rect = cv::minAreaRect(input_points);
            rotated_rects.push_back(result_rotated_rect);
            target_is_found = true;
        }
    }
    if (target_is_found == false) {
        return std::nullopt;
    }
    return rotated_rects;
}

cv::Mat draw_rotated_rectangle(
        const cv::Mat image, const cv::RotatedRect rotated_rect, const cv::Scalar color, const int thickness) {
    cv::Mat drawed_img = image.clone();
    cv::Point2f vertexes[4];
    rotated_rect.points(vertexes);
    for (int i = 0; i < 4; i++) {
        cv::line(drawed_img, vertexes[i], vertexes[i + 1 < 4 ? i + 1 : 0], color, thickness, cv::LINE_4);
    }
    return drawed_img;
}

int main(void) {
    std::string file_path = "../data/rotated_rect_sample.png";
    const cv::Mat loaded_image = load_image(file_path);

    const cv::Mat binary_image = binary(loaded_image, 0);
    std::optional<std::vector<cv::RotatedRect>> maybe_rotated_rects = get_rotated_rects(loaded_image);

    // 検出できなかった場合は、プログラムを終了する。
    if (maybe_rotated_rects == std::nullopt) {
        std::cout << "There are no objects." << std::endl;
        cv::imshow("window", loaded_image);
        cv::waitKey(0);
        return -1;
    }

    // 検出できた場合には、すべての矩形を描画する。
    const std::vector<cv::RotatedRect> rotated_rects = maybe_rotated_rects.value();
    cv::Mat result_image = loaded_image.clone();
    for (int i = 0; i < static_cast<int>(rotated_rects.size()); i++) {
        result_image = draw_rotated_rectangle(result_image, rotated_rects[i], cv::Scalar(0, 0, 255), 3);
    }

    cv::imshow("window", result_image);
    cv::waitKey(0);
}
```

## おわりに
人手作業をロボットアームで自動化するために、カメラを使ったロボット制御＝ビジュアルフィードバック制御が大切です。
ロボット制御用の画像認識でも中身のひとつひとつはシンプルなので、要素に分解して解説していきたいと思います。