【C++】OpenCVでテクスチャ分類を実装：LBPとGLCMで特徴量抽出しPCA＋SVMで高精度分類

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像の読み込み
    cv::Mat colorImage = cv::imread("texture_image.jpg");
    if (colorImage.empty()) {
        std::cerr << "画像が見つかりません。" << std::endl;
        return -1;
    }
    // グレースケールに変換
    cv::Mat grayImage;
    cv::cvtColor(colorImage, grayImage, cv::COLOR_BGR2GRAY);
    // 変換結果の表示
    cv::imshow("グレースケール画像", grayImage);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    // 画像の読み込み
    cv::Mat grayImage = cv::imread("texture_image.jpg", cv::IMREAD_GRAYSCALE);
    if (grayImage.empty()) {
        std::cerr << "画像が見つかりません。" << std::endl;
        return -1;
    }
    // 3x3ガウシアンフィルタ
    cv::Mat smooth3x3;
    cv::GaussianBlur(grayImage, smooth3x3, cv::Size(3, 3), 0);
    // 5x5ガウシアンフィルタ
    cv::Mat smooth5x5;
    cv::GaussianBlur(grayImage, smooth5x5, cv::Size(5, 5), 0);
    // 7x7ガウシアンフィルタ
    cv::Mat smooth7x7;
    cv::GaussianBlur(grayImage, smooth7x7, cv::Size(7, 7), 0);
    // 画像の表示
    cv::imshow("元画像", grayImage);
    cv::imshow("3x3平滑化", smooth3x3);
    cv::imshow("5x5平滑化", smooth5x5);
    cv::imshow("7x7平滑化", smooth7x7);
    cv::waitKey(0);
    return 0;
}

// 標準LBPの実装例(簡略化版)
#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <cmath>
int main() {
    // 画像の読み込み(グレースケール)
    cv::Mat grayImage = cv::imread("texture_image.jpg", cv::IMREAD_GRAYSCALE);
    if (grayImage.empty()) {
        std::cerr << "画像が見つかりません。" << std::endl;
        return -1;
    }
    // パラメータ設定
    int P = 8; // 隣接点数
    int R = 1; // 半径
    cv::Mat lbpImage = cv::Mat::zeros(grayImage.size(), CV_8UC1);
    // 画像の中央ピクセルを除き、LBP計算
    for (int y = R; y < grayImage.rows - R; ++y) {
        for (int x = R; x < grayImage.cols - R; ++x) {
            unsigned char center = grayImage.at<uchar>(y, x);
            unsigned char code = 0;
            // 8つのサンプル点の角度
            for (int n = 0; n < P; ++n) {
                double theta = 2.0 * CV_PI * n / P;
                int sampleX = static_cast<int>(x + R * cos(theta));
                int sampleY = static_cast<int>(y - R * sin(theta));
                // サンプル点の値
                unsigned char sampleVal = grayImage.at<uchar>(sampleY, sampleX);
                // 比較してビットを設定
                code |= (sampleVal >= center) << n;
            }
            lbpImage.at<uchar>(y, x) = code;
        }
    }
    // 結果の表示
    cv::imshow("LBP画像", lbpImage);
    cv::waitKey(0);
    return 0;
}

// 回転不変LBPの例(符号の最小化)
#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <algorithm>
unsigned char rotateRight(unsigned char val, int shift) {
    return (val >> shift) | (val << (8 - shift));
}
unsigned char getUniformPattern(unsigned char pattern) {
    unsigned char minPattern = pattern;
    for (int i = 1; i < 8; ++i) {
        unsigned char rotated = rotateRight(pattern, i);
        if (rotated < minPattern) {
            minPattern = rotated;
        }
    }
    return minPattern;
}
int main() {
    // 画像の読み込み(グレースケール)
    cv::Mat grayImage = cv::imread("texture_image.jpg", cv::IMREAD_GRAYSCALE);
    if (grayImage.empty()) {
        std::cerr << "画像が見つかりません。" << std::endl;
        return -1;
    }
    int P = 8;
    int R = 1;
    cv::Mat lbpRotInvImage = cv::Mat::zeros(grayImage.size(), CV_8UC1);
    for (int y = R; y < grayImage.rows - R; ++y) {
        for (int x = R; x < grayImage.cols - R; ++x) {
            unsigned char center = grayImage.at<uchar>(y, x);
            unsigned char pattern = 0;
            for (int n = 0; n < P; ++n) {
                double theta = 2.0 * CV_PI * n / P;
                int sampleX = static_cast<int>(x + R * cos(theta));
                int sampleY = static_cast<int>(y - R * sin(theta));
                unsigned char sampleVal = grayImage.at<uchar>(sampleY, sampleX);
                pattern |= (sampleVal >= center) << n;
            }
            // 回転不変パターンの取得
            unsigned char uniformPattern = getUniformPattern(pattern);
            lbpRotInvImage.at<uchar>(y, x) = uniformPattern;
        }
    }
    // 結果の表示
    cv::imshow("回転不変LBP画像", lbpRotInvImage);
    cv::waitKey(0);
    return 0;
}

// 例：距離1ピクセル、角度0度の共起行列の設定
int distance = 1;
double angle = 0.0; // 0度

// 例：距離1、角度0度の共起行列の生成
#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
cv::Mat computeGLCM(const cv::Mat& image, int distance, double angle) {
    int levels = 256; // 8ビット画像
    cv::Mat glcm = cv::Mat::zeros(levels, levels, CV_32F);
    int dx = static_cast<int>(round(distance * cos(angle)));
    int dy = static_cast<int>(round(distance * sin(angle)));
    for (int y = 0; y < image.rows - dy; ++y) {
        for (int x = 0; x < image.cols - dx; ++x) {
            int i = image.at<uchar>(y, x);
            int j = image.at<uchar>(y + dy, x + dx);
            glcm.at<float>(i, j) += 1.0f;
        }
    }
    // 正規化
    glcm /= cv::sum(glcm)[0];
    return glcm;
}

// 例：コントラストの計算
double computeContrast(const cv::Mat& glcm) {
    double contrast = 0.0;
    for (int i = 0; i < glcm.rows; ++i) {
        for (int j = 0; j < glcm.cols; ++j) {
            contrast += (i - j) * (i - j) * glcm.at<float>(i, j);
        }
    }
    return contrast;
}

// 例：複数の特徴量ベクトルを結合する
#include <vector>
#include <iostream>
std::vector<double> concatenateFeatures(const std::vector<double>& feature1,
                                       const std::vector<double>& feature2,
                                       const std::vector<double>& feature3) {
    std::vector<double> combined;
    combined.reserve(feature1.size() + feature2.size() + feature3.size());
    combined.insert(combined.end(), feature1.begin(), feature1.end());
    combined.insert(combined.end(), feature2.begin(), feature2.end());
    combined.insert(combined.end(), feature3.begin(), feature3.end());
    return combined;
}
int main() {
    // 仮の特徴量ベクトル
    std::vector<double> lbpHist = {0.1, 0.2, 0.3};
    std::vector<double> glcmStats = {0.5, 0.6};
    std::vector<double> hogFeatures = {0.7, 0.8, 0.9};
    // 結合
    std::vector<double> featureVector = concatenateFeatures(lbpHist, glcmStats, hogFeatures);
    // 結果表示
    for (double val : featureVector) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}

0.1 0.2 0.3 0.5 0.6 0.7 0.8 0.9 

// 標準化の例
#include <vector>
#include <numeric>
#include <cmath>
#include <iostream>
void standardize(std::vector<double>& data) {
    double sum = std::accumulate(data.begin(), data.end(), 0.0);
    double mean = sum / data.size();
    double accum = 0.0;
    for (double val : data) {
        accum += (val - mean) * (val - mean);
    }
    double stddev = std::sqrt(accum / data.size());
    for (double& val : data) {
        val = (val - mean) / stddev;
    }
}
int main() {
    std::vector<double> features = {10.0, 20.0, 15.0, 25.0, 30.0};
    standardize(features);
    // 結果表示
    for (double val : features) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}

-1.41421 0 -0.707107 0.707107 1.41421 

// 最小  -最大正規化の例
#include <vector>
#include <algorithm>
#include <iostream>
void minMaxNormalize(std::vector<double>& data) {
    auto minmax = std::minmax_element(data.begin(), data.end());
    double minVal = *minmax.first;
    double maxVal = *minmax.second;
    for (double& val : data) {
        val = (val - minVal) / (maxVal - minVal);
    }
}
int main() {
    std::vector<double> features = {10.0, 20.0, 15.0, 25.0, 30.0};
    minMaxNormalize(features);
    // 結果表示
    for (double val : features) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}

0 0.5 0.25 0.75 1 

// 例：特徴行列の構築
#include <vector>
#include <iostream>
int main() {
    // 例：3サンプル、4特徴量のデータ
    std::vector<std::vector<double>> featureMatrix = {
        {1.0, 2.0, 3.0, 4.0},
        {2.0, 3.0, 4.0, 5.0},
        {3.0, 4.0, 5.0, 6.0}
    };
    // ここでは、行列の平均や分散計算に進む
    // 実際にはEigenやOpenCVのcv::Matを使うと便利
    return 0;
}

// Eigenライブラリを用いた例
#include "Eigen/Dense"
#include <iostream>
int main() {
    Eigen::MatrixXd data(3, 4);
    data << 1, 2, 3, 4,
            2, 3, 4, 5,
            3, 4, 5, 6;
    // 各特徴量の平均を引く
    Eigen::RowVectorXd mean = data.colwise().mean();
    Eigen::MatrixXd centered = data.rowwise() - mean;
    // 共分散行列の計算
    Eigen::MatrixXd cov = (centered.adjoint() * centered) / double(data.rows() - 1);
    // 固有値・固有ベクトルの計算
    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> eig(cov);
    Eigen::VectorXd eigenvalues = eig.eigenvalues();
    Eigen::MatrixXd eigenvectors = eig.eigenvectors();
    // 固有値と固有ベクトルの出力
    std::cout << "固有値:\n" << eigenvalues << std::endl;
    std::cout << "固有ベクトル:\n" << eigenvectors << std::endl;
    return 0;
}

固有値:
-4.44089e-16
-2.16412e-16
           0
           4
固有ベクトル:
           0    -0.866025            0          0.5
    0.816497     0.288675 -8.75605e-17          0.5
   -0.408248     0.288675    -0.707107          0.5
   -0.408248     0.288675     0.707107          0.5

// Eigenライブラリを用いた例：累積寄与率の計算
#include <iostream>
#include <numeric>
#include <vector>
#include "Eigen/Dense"
int main() {
    Eigen::VectorXd eigenvalues(4);
    eigenvalues << 3.0, 2.0, 0.5, 0.2;
    double total = eigenvalues.sum();
    std::vector<double> cumulative;
    double sum = 0.0;
    for (int i = 0; i < eigenvalues.size(); ++i) {
        sum += eigenvalues(i);
        cumulative.push_back(sum / total);
    }
    // 累積寄与率が95%以上になる最小の主成分数を探す
    int numComponents = 0;
    for (size_t i = 0; i < cumulative.size(); ++i) {
        if (cumulative[i] >= 0.95) {
            numComponents = i + 1;
            break;
        }
    }
    std::cout << "選択する主成分の数: " << numComponents << std::endl;
    return 0;
}

選択する主成分の数: 3

// OpenCVのSVMで線形カーネルを設定する例
#include <opencv2/opencv.hpp>
#include <opencv2/ml.hpp>
int main() {
    cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
    svm->setType(cv::ml::SVM::C_SVC);
    svm->setKernel(cv::ml::SVM::LINEAR);
    // 他のパラメータ設定や学習は後述
    return 0;
}

// RBFカーネルの設定例
#include <opencv2/opencv.hpp>
#include <opencv2/ml.hpp>
int main() {
    cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
    svm->setType(cv::ml::SVM::C_SVC);
    svm->setKernel(cv::ml::SVM::RBF);
    // 他のパラメータ設定や学習は後述
    return 0;
}

// Cパラメータの設定例
svm->setC(1.0); // 例：C=1.0

// γパラメータの設定例
svm->setGamma(0.5); // 例：γ=0.5

// 例：特徴量とラベルの準備
#include <opencv2/opencv.hpp>
#include <opencv2/ml.hpp>
int main() {
    cv::Mat trainingData; // 特徴量行列(サンプル数×特徴量数)
    cv::Mat labels;       // ラベル(サンプル数×1)
    // 例：データの読み込みや作成は省略
    // trainingData = ...
    // labels = ...
    cv::Ptr<cv::ml::TrainData> tData = cv::ml::TrainData::create(trainingData, cv::ml::ROW_SAMPLE, labels);
    return 0;
}

// モデルの保存
svm->save("svm_model.xml");
// モデルのロード
cv::Ptr<cv::ml::SVM> svm_loaded = cv::ml::SVM::load("svm_model.xml");

// 例：正確度の計算
#include <iostream>
#include <vector>
int main() {
    int correct = 85; // 正解数
    int total = 100;  // 総サンプル数
    double accuracy = static_cast<double>(correct) / total;
    std::cout << "正確度: " << accuracy * 100 << "%" << std::endl;
    return 0;
}

// 例：再現率の計算
#include <iostream>
int main() {
    int true_positive = 40;
    int false_negative = 10;
    double recall = static_cast<double>(true_positive) / (true_positive + false_negative);
    std::cout << "再現率: " << recall * 100 << "%" << std::endl;
    return 0;
}

// 例：F1スコアの計算
#include <iostream>
int main() {
    double precision = 0.8; // 仮の値
    double recall = 0.75;   // 仮の値
    double f1_score = 2 * (precision * recall) / (precision + recall);
    std::cout << "F1スコア: " << f1_score << std::endl;
    return 0;
}

// 混同行列の例(出力のみ)
#include <iostream>
#include <vector>
int main() {
    // 例：2クラスの混同行列
    std::vector<std::vector<int>> confusionMatrix = {
        {50, 10},
        {5, 35}
    };
    std::cout << "混同行列:\n";
    std::cout << "          予測正例  予測負例\n";
    std::cout << "実際正例   " << confusionMatrix[0][0] << "        " << confusionMatrix[0][1] << "\n";
    std::cout << "実際負例   " << confusionMatrix[1][0] << "        " << confusionMatrix[1][1] << "\n";
    return 0;
}

// ROC曲線とAUCの計算は、外部ライブラリやツールを用いることが一般的です。
// 例：Pythonのscikit-learnやRのpROCパッケージがよく使われます。
// C++では、OpenCVや他のライブラリを用いて計算・可視化します。

// 例：OpenCVのGridSearchは標準では提供されていませんが、手動で実装可能
// 例示のための擬似コード
#include <vector>
#include <iostream>
int main() {
    std::vector<double> C_values = {0.1, 1.0, 10.0};
    std::vector<double> gamma_values = {0.01, 0.1, 1.0};
    double bestScore = -1.0;
    double bestC = 0.0;
    double bestGamma = 0.0;
    for (double C : C_values) {
        for (double gamma : gamma_values) {
            // SVMの設定と学習
            // cv::ml::SVM::create() などを用いて設定
            // 学習と評価を行い、スコアを計算
            double score = evaluateModel(C, gamma); // 仮の関数
            if (score > bestScore) {
                bestScore = score;
                bestC = C;
                bestGamma = gamma;
            }
        }
    }
    std::cout << "最適なC: " << bestC << ", 最適なγ: " << bestGamma << std::endl;
    return 0;
}

// 例：OpenCVには直接的なk-fold交差検証の関数はないため、自前で実装
#include <algorithm>
#include <iostream>
#include <vector>
#include <opencv2/opencv.hpp>
void kFoldCrossValidation(const std::vector<cv::Mat>& data,
                          const std::vector<int>& labels, int k) {
    int foldSize = data.size() / k;
    std::vector<double> scores;
    for (int i = 0; i < k; ++i) {
        // データの分割
        std::vector<cv::Mat> trainData, testData;
        std::vector<int> trainLabels, testLabels;
        for (int j = 0; j < data.size(); ++j) {
            if (j >= i * foldSize && j < (i + 1) * foldSize) {
                testData.push_back(data[j]);
                testLabels.push_back(labels[j]);
            } else {
                trainData.push_back(data[j]);
                trainLabels.push_back(labels[j]);
            }
        }
        // 学習と評価
        double score =
            trainAndEvaluateModel(trainData, trainLabels, testData, testLabels);
        scores.push_back(score);
    }
    // 評価結果の平均
    double sum = std::accumulate(scores.begin(), scores.end(), 0.0);
    double meanScore = sum / scores.size();
    std::cout << "平均評価スコア: " << meanScore << std::endl;
}
int main() {
    // データとラベルの準備は省略
    std::vector<cv::Mat> data; // 例：特徴量の行列
    std::vector<int> labels;   // 例：クラスラベル
    int k = 5;                 // 5-fold交差検証
    kFoldCrossValidation(data, labels, k);
    return 0;
}

// OpenCVのparallel_for_を用いた例
#include <opencv2/opencv.hpp>
#include <opencv2/core/parallel/parallel.hpp>
class MyParallelLoop : public cv::ParallelLoopBody {
public:
    void operator()(const cv::Range& range) const override {
        for (int i = range.start; i < range.end; ++i) {
            // ピクセルごとの処理
            // 例：LBPやGLCMの計算
        }
    }
};
int main() {
    cv::Mat image; // 画像データ
    // 画像の前処理や特徴抽出の並列化
    cv::parallel_for_(cv::Range(0, image.rows), MyParallelLoop());
    return 0;
}

// cv::Matのメモリ管理例
cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
cv::Mat dst = src; // 参照カウント増加、コピーは遅くない
// 必要に応じて深いコピー
cv::Mat deepCopy;
src.copyTo(deepCopy);

// AVXを用いた例(コンパイラの自動ベクトル化を促すための例)
#include <immintrin.h>
#include <iostream>
int main() {
    __m256d vec1 = _mm256_set1_pd(1.0);
    __m256d vec2 = _mm256_set1_pd(2.0);
    __m256d result = _mm256_add_pd(vec1, vec2);
    double res[4];
    _mm256_storeu_pd(res, result);
    for (int i = 0; i < 4; ++i) {
        std::cout << res[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

// 異常値検出例(Zスコアを用いる)
#include <vector>
#include <cmath>
#include <iostream>
void detectOutliers(const std::vector<double>& data, double threshold = 3.0) {
    double sum = 0.0;
    for (double v : data) sum += v;
    double mean = sum / data.size();
    double accum = 0.0;
    for (double v : data) accum += (v - mean) * (v - mean);
    double stddev = std::sqrt(accum / data.size());
    for (size_t i = 0; i < data.size(); ++i) {
        double z = (data[i] - mean) / stddev;
        if (std::abs(z) > threshold) {
            std::cout << "異常値検出: インデックス " << i << " 値 " << data[i] << std::endl;
        }
    }
}

// 例：SVMのハイパーパラメータ調整
#include <opencv2/opencv.hpp>
#include <opencv2/ml.hpp>
void tuneHyperparameters() {
    cv::Ptr<cv::ml::SVM> svm = cv::ml::SVM::create();
    svm->setType(cv::ml::SVM::C_SVC);
    svm->setKernel(cv::ml::SVM::RBF);
    svm->setC(1.0);
    svm->setGamma(0.5);
    // 追加の調整や交差検証を行う
}

// メモリの効率的な管理例
#include <opencv2/opencv.hpp>
int main() {
    cv::Mat image = cv::imread("large_image.jpg");
    // 画像の解像度を縮小
    cv::Mat resized;
    cv::resize(image, resized, cv::Size(), 0.5, 0.5);
    // 必要な処理を行う
    return 0;
}