【C++】OpenCV×Tesseractで作るリアルタイム自動車ナンバープレート認識入門

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::VideoCapture cap(0); // カメラデバイス0を開く
    if (!cap.isOpened()) {
        std::cerr << "カメラを開けませんでした" << std::endl;
        return -1;
    }
    cv::Mat frame;
    while (true) {
        cap >> frame; // フレームを取得
        if (frame.empty()) break;
        cv::imshow("Camera Frame", frame);
        if (cv::waitKey(30) >= 0) break; // キー入力で終了
    }
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat preprocessImage(const cv::Mat& src) {
    cv::Mat gray, blurred, claheImg;
    // グレースケール変換
    cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);
    // ノイズ除去(ガウシアンブラー)
    cv::GaussianBlur(gray, blurred, cv::Size(5, 5), 0);
    // CLAHEでコントラスト強調
    cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE();
    clahe->setClipLimit(2.0);
    clahe->apply(blurred, claheImg);
    return claheImg;
}

#include <opencv2/opencv.hpp>
#include <vector>
std::vector<cv::Rect> detectPlateCandidates(const cv::Mat& preprocessed) {
    std::vector<cv::Rect> candidates;
    cv::Mat edges;
    cv::Canny(preprocessed, edges, 100, 200);
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(edges, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
    for (const auto& contour : contours) {
        double area = cv::contourArea(contour);
        if (area < 1000) continue; // 小さい輪郭は除外
        std::vector<cv::Point> approx;
        cv::approxPolyDP(contour, approx, 0.02 * cv::arcLength(contour, true), true);
        if (approx.size() == 4 && cv::isContourConvex(approx)) {
            cv::Rect rect = cv::boundingRect(approx);
            float aspectRatio = (float)rect.width / rect.height;
            if (aspectRatio > 2 && aspectRatio < 5) { // ナンバープレートの比率に近い
                candidates.push_back(rect);
            }
        }
    }
    return candidates;
}

#include <opencv2/opencv.hpp>
cv::Mat warpPlate(const cv::Mat& src, const cv::Rect& plateRect) {
    cv::Mat plate = src(plateRect).clone();
    // ここでは簡単に切り出しのみ。透視変換は輪郭の4点座標が必要
    // 実際はapproxPolyDPで得た4点を使い、getPerspectiveTransformで変換行列を作成します
    return plate;
}

#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>
#include <opencv2/opencv.hpp>
#include <iostream>
std::string recognizeText(const cv::Mat& plateImg) {
    tesseract::TessBaseAPI tess;
    if (tess.Init(NULL, "jpn", tesseract::OEM_LSTM_ONLY)) {
        std::cerr << "Tesseractの初期化に失敗しました" << std::endl;
        return "";
    }
    tess.SetPageSegMode(tesseract::PSM_SINGLE_BLOCK);
    tess.SetImage(plateImg.data, plateImg.cols, plateImg.rows, plateImg.channels(), plateImg.step);
    char* outText = tess.GetUTF8Text();
    std::string result(outText);
    delete[] outText;
    return result;
}
int main() {
    cv::Mat plateImg = cv::imread("plate_sample.jpg", cv::IMREAD_GRAYSCALE);
    if (plateImg.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    std::string text = recognizeText(plateImg);
    std::cout << "認識結果: " << text << std::endl;
    return 0;
}

#include <regex>
#include <iostream>
std::string normalizePlateText(const std::string& rawText) {
    // 全角数字を半角に変換(簡易例)
    std::string normalized;
    for (char c : rawText) {
        if (c >= '0' && c <= '9') {
            normalized += c - '0' + '0';
        } else {
            normalized += c;
        }
    }
    // 正規表現でナンバープレート形式にマッチする部分を抽出
    std::regex platePattern(R"((\d{2,3})\s*([あ-ん])\s*(\d{4}))");
    std::smatch match;
    if (std::regex_search(normalized, match, platePattern)) {
        return match.str(0);
    }
    return normalized;
}
int main() {
    std::string ocrResult = "123 あ 4567";
    std::string cleaned = normalizePlateText(ocrResult);
    std::cout << "整形後の文字列: " << cleaned << std::endl;
    return 0;
}

整形後の文字列: 123 あ 4567

#include <opencv2/opencv.hpp>
cv::Mat convertToGray(const cv::Mat& src) {
    cv::Mat gray;
    cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);
    return gray;
}
int main() {
    cv::Mat img = cv::imread("car.jpg");
    if (img.empty()) return -1;
    cv::Mat grayImg = convertToGray(img);
    cv::imshow("Gray Image", grayImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat extractColorMask(const cv::Mat& src) {
    cv::Mat hsv, mask;
    cv::cvtColor(src, hsv, cv::COLOR_BGR2HSV);
    // 白色の範囲をHSVで指定(例)
    cv::Scalar lowerWhite(0, 0, 200);
    cv::Scalar upperWhite(180, 30, 255);
    cv::inRange(hsv, lowerWhite, upperWhite, mask);
    return mask;
}
int main() {
    cv::Mat img = cv::imread("car.jpg");
    if (img.empty()) return -1;
    cv::Mat whiteMask = extractColorMask(img);
    cv::imshow("White Mask", whiteMask);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat applyGaussianBlur(const cv::Mat& src) {
    cv::Mat blurred;
    cv::GaussianBlur(src, blurred, cv::Size(5, 5), 0);
    return blurred;
}
int main() {
    cv::Mat img = cv::imread("plate_gray.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat blurredImg = applyGaussianBlur(img);
    cv::imshow("Gaussian Blur", blurredImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat applyBilateralFilter(const cv::Mat& src) {
    cv::Mat filtered;
    cv::bilateralFilter(src, filtered, 9, 75, 75);
    return filtered;
}
int main() {
    cv::Mat img = cv::imread("plate_gray.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat filteredImg = applyBilateralFilter(img);
    cv::imshow("Bilateral Filter", filteredImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat applyCLAHE(const cv::Mat& src) {
    cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE();
    clahe->setClipLimit(2.0);
    cv::Mat dst;
    clahe->apply(src, dst);
    return dst;
}
int main() {
    cv::Mat img = cv::imread("plate_gray.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat claheImg = applyCLAHE(img);
    cv::imshow("CLAHE", claheImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat applySobel(const cv::Mat& src) {
    cv::Mat gradX, gradY, absGradX, absGradY, grad;
    // X方向の勾配
    cv::Sobel(src, gradX, CV_16S, 1, 0, 3);
    cv::convertScaleAbs(gradX, absGradX);
    // Y方向の勾配
    cv::Sobel(src, gradY, CV_16S, 0, 1, 3);
    cv::convertScaleAbs(gradY, absGradY);
    // X,Yの勾配を合成
    cv::addWeighted(absGradX, 0.5, absGradY, 0.5, 0, grad);
    return grad;
}
int main() {
    cv::Mat img = cv::imread("plate_gray.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::Mat sobelImg = applySobel(img);
    cv::imshow("Sobel Edge", sobelImg);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat applyCanny(const cv::Mat& src, double lowThresh, double highThresh) {
    cv::Mat edges;
    cv::Canny(src, edges, lowThresh, highThresh);
    return edges;
}
int main() {
    cv::Mat img = cv::imread("plate_gray.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    double lowThreshold = 50;
    double highThreshold = 150;
    cv::Mat edges = applyCanny(img, lowThreshold, highThreshold);
    cv::imshow("Canny Edges", edges);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
std::vector<std::vector<cv::Point>> extractContours(const cv::Mat& edgeImg) {
    std::vector<std::vector<cv::Point>> contours;
    cv::findContours(edgeImg, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
    return contours;
}
int main() {
    cv::Mat img = cv::imread("plate_edges.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    auto contours = extractContours(img);
    cv::Mat output = cv::Mat::zeros(img.size(), CV_8UC3);
    for (const auto& contour : contours) {
        cv::drawContours(output, std::vector<std::vector<cv::Point>>{contour}, -1, cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Contours", output);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
std::vector<cv::Rect> filterContours(const std::vector<std::vector<cv::Point>>& contours) {
    std::vector<cv::Rect> candidates;
    for (const auto& contour : contours) {
        double area = cv::contourArea(contour);
        if (area < 1000) continue; // 小さい輪郭は除外
        cv::Rect rect = cv::boundingRect(contour);
        float aspectRatio = static_cast<float>(rect.width) / rect.height;
        if (aspectRatio > 2.0 && aspectRatio < 5.0) {
            candidates.push_back(rect);
        }
    }
    return candidates;
}

#include <opencv2/opencv.hpp>
#include <vector>
bool isRectangle(const std::vector<cv::Point>& contour) {
    std::vector<cv::Point> approx;
    double epsilon = 0.02 * cv::arcLength(contour, true);
    cv::approxPolyDP(contour, approx, epsilon, true);
    return (approx.size() == 4 && cv::isContourConvex(approx));
}

#include <opencv2/opencv.hpp>
#include <vector>
cv::Mat correctPerspective(const cv::Mat& src, const std::vector<cv::Point>& quad) {
    // 4点を順序付け(左上、右上、右下、左下)
    std::vector<cv::Point2f> srcPts(4);
    for (int i = 0; i < 4; ++i) {
        srcPts[i] = quad[i];
    }
    // 出力画像のサイズを計算
    float widthA = cv::norm(srcPts[2] - srcPts[3]);
    float widthB = cv::norm(srcPts[1] - srcPts[0]);
    float maxWidth = std::max(widthA, widthB);
    float heightA = cv::norm(srcPts[1] - srcPts[2]);
    float heightB = cv::norm(srcPts[0] - srcPts[3]);
    float maxHeight = std::max(heightA, heightB);
    std::vector<cv::Point2f> dstPts = {
        cv::Point2f(0, 0),
        cv::Point2f(maxWidth - 1, 0),
        cv::Point2f(maxWidth - 1, maxHeight - 1),
        cv::Point2f(0, maxHeight - 1)
    };
    cv::Mat M = cv::getPerspectiveTransform(srcPts, dstPts);
    cv::Mat warped;
    cv::warpPerspective(src, warped, M, cv::Size(maxWidth, maxHeight));
    return warped;
}

#include <opencv2/opencv.hpp>
cv::Mat createGreenPlateMask(const cv::Mat& src) {
    cv::Mat hsv;
    cv::cvtColor(src, hsv, cv::COLOR_BGR2HSV);
    // 緑色の範囲(例)
    cv::Scalar lowerGreen(40, 40, 40);
    cv::Scalar upperGreen(80, 255, 255);
    cv::Mat mask;
    cv::inRange(hsv, lowerGreen, upperGreen, mask);
    return mask;
}

#include <opencv2/opencv.hpp>
cv::Mat applyAdaptiveThreshold(const cv::Mat& src) {
    cv::Mat binarized;
    cv::adaptiveThreshold(src, binarized, 255,
                          cv::ADAPTIVE_THRESH_GAUSSIAN_C,
                          cv::THRESH_BINARY_INV, 11, 2);
    return binarized;
}

// YOLOv5推論はコードが長いため割愛しますが、
// モデルの読み込み、前処理、推論、後処理の流れで実装します。

#include <opencv2/opencv.hpp>
int main() {
    cv::CascadeClassifier plateCascade;
    if (!plateCascade.load("haarcascade_russian_plate_number.xml")) {
        std::cerr << "カスケードファイルの読み込みに失敗しました" << std::endl;
        return -1;
    }
    cv::Mat img = cv::imread("car.jpg");
    if (img.empty()) return -1;
    std::vector<cv::Rect> plates;
    plateCascade.detectMultiScale(img, plates, 1.1, 3);
    for (const auto& rect : plates) {
        cv::rectangle(img, rect, cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Detected Plates", img);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
cv::Mat getTransformMatrix(const std::vector<cv::Point2f>& srcPoints, const std::vector<cv::Point2f>& dstPoints) {
    return cv::getPerspectiveTransform(srcPoints, dstPoints);
}
int main() {
    // 例：歪んだナンバープレートの4点(左上、右上、右下、左下)
    std::vector<cv::Point2f> srcPoints = {
        cv::Point2f(100, 200),
        cv::Point2f(400, 180),
        cv::Point2f(420, 300),
        cv::Point2f(120, 320)
    };
    // 変換後の長方形の4点(幅400、高さ120)
    std::vector<cv::Point2f> dstPoints = {
        cv::Point2f(0, 0),
        cv::Point2f(400, 0),
        cv::Point2f(400, 120),
        cv::Point2f(0, 120)
    };
    cv::Mat M = getTransformMatrix(srcPoints, dstPoints);
    std::cout << "透視変換行列:\n" << M << std::endl;
    return 0;
}

#include <opencv2/opencv.hpp>
cv::Mat warpPlateImage(const cv::Mat& src, const cv::Mat& M, int width, int height) {
    cv::Mat warped;
    cv::warpPerspective(src, warped, M, cv::Size(width, height));
    return warped;
}
int main() {
    cv::Mat src = cv::imread("car.jpg");
    if (src.empty()) return -1;
    std::vector<cv::Point2f> srcPoints = {
        cv::Point2f(100, 200),
        cv::Point2f(400, 180),
        cv::Point2f(420, 300),
        cv::Point2f(120, 320)
    };
    int width = 400;
    int height = 120;
    std::vector<cv::Point2f> dstPoints = {
        cv::Point2f(0, 0),
        cv::Point2f(width, 0),
        cv::Point2f(width, height),
        cv::Point2f(0, height)
    };
    cv::Mat M = cv::getPerspectiveTransform(srcPoints, dstPoints);
    cv::Mat warped = warpPlateImage(src, M, width, height);
    cv::imshow("Warped Plate", warped);
    cv::waitKey(0);
    return 0;
}

cv::Mat warpPlateImageHighQuality(const cv::Mat& src, const cv::Mat& M, int width, int height) {
    cv::Mat warped;
    cv::warpPerspective(src, warped, M, cv::Size(width, height), cv::INTER_CUBIC);
    return warped;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
void showProjectionHistograms(const cv::Mat& binaryImg) {
    int rows = binaryImg.rows;
    int cols = binaryImg.cols;
    // 水平投影ヒストグラム
    std::vector<int> horizontalHist(rows, 0);
    for (int y = 0; y < rows; ++y) {
        int count = 0;
        for (int x = 0; x < cols; ++x) {
            if (binaryImg.at<uchar>(y, x) > 0) count++;
        }
        horizontalHist[y] = count;
    }
    // 垂直投影ヒストグラム
    std::vector<int> verticalHist(cols, 0);
    for (int x = 0; x < cols; ++x) {
        int count = 0;
        for (int y = 0; y < rows; ++y) {
            if (binaryImg.at<uchar>(y, x) > 0) count++;
        }
        verticalHist[x] = count;
    }
    // ヒストグラムの簡易表示
    std::cout << "水平投影ヒストグラム(上位10行):" << std::endl;
    for (int i = 0; i < 10 && i < rows; ++i) {
        std::cout << "Row " << i << ": " << horizontalHist[i] << std::endl;
    }
    std::cout << "垂直投影ヒストグラム(左端10列):" << std::endl;
    for (int i = 0; i < 10 && i < cols; ++i) {
        std::cout << "Col " << i << ": " << verticalHist[i] << std::endl;
    }
}
int main() {
    cv::Mat plateImg = cv::imread("plate_binary.jpg", cv::IMREAD_GRAYSCALE);
    if (plateImg.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    showProjectionHistograms(plateImg);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat binaryImg = cv::imread("plate_binary.jpg", cv::IMREAD_GRAYSCALE);
    if (binaryImg.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    cv::Mat labels, stats, centroids;
    int nLabels = cv::connectedComponentsWithStats(binaryImg, labels, stats, centroids);
    std::cout << "検出されたラベル数: " << nLabels - 1 << std::endl; // 背景を除く
    cv::Mat output = cv::Mat::zeros(binaryImg.size(), CV_8UC3);
    for (int i = 1; i < nLabels; ++i) { // 0は背景
        int x = stats.at<int>(i, cv::CC_STAT_LEFT);
        int y = stats.at<int>(i, cv::CC_STAT_TOP);
        int w = stats.at<int>(i, cv::CC_STAT_WIDTH);
        int h = stats.at<int>(i, cv::CC_STAT_HEIGHT);
        cv::rectangle(output, cv::Rect(x, y, w, h), cv::Scalar(0, 255, 0), 2);
    }
    cv::imshow("Connected Components", output);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <vector>
#include <iostream>
struct CharacterRegion {
    cv::Rect rect;
    std::string type; // "classification", "kana", "number"
};
std::vector<CharacterRegion> estimateCharacterPositions(const std::vector<cv::Rect>& charRects, int plateWidth) {
    std::vector<CharacterRegion> regions;
    for (const auto& rect : charRects) {
        float centerX = rect.x + rect.width / 2.0f;
        if (centerX < plateWidth * 0.3) {
            regions.push_back({rect, "classification"});
        } else if (centerX < plateWidth * 0.5) {
            regions.push_back({rect, "kana"});
        } else {
            regions.push_back({rect, "number"});
        }
    }
    return regions;
}
int main() {
    // 例としてconnectedComponentsで得た文字矩形を用意
    std::vector<cv::Rect> charRects = {
        cv::Rect(10, 20, 30, 50),  // 分類番号
        cv::Rect(50, 20, 25, 50),  // ひらがな
        cv::Rect(90, 20, 25, 50),  // 登録番号1
        cv::Rect(120, 20, 25, 50), // 登録番号2
        cv::Rect(150, 20, 25, 50), // 登録番号3
        cv::Rect(180, 20, 25, 50)  // 登録番号4
    };
    int plateWidth = 220;
    auto regions = estimateCharacterPositions(charRects, plateWidth);
    for (const auto& region : regions) {
        std::cout << "領域: " << region.rect << " 種類: " << region.type << std::endl;
    }
    return 0;
}

#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>
#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat plateImg = cv::imread("plate_warped.jpg", cv::IMREAD_GRAYSCALE);
    if (plateImg.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    tesseract::TessBaseAPI tess;
    if (tess.Init(NULL, "jpn", tesseract::OEM_LSTM_ONLY)) {
        std::cerr << "Tesseractの初期化に失敗しました" << std::endl;
        return -1;
    }
    tess.SetPageSegMode(tesseract::PSM_SINGLE_LINE); // 単一行モード
    tess.SetImage(plateImg.data, plateImg.cols, plateImg.rows, plateImg.channels(), plateImg.step);
    char* outText = tess.GetUTF8Text();
    std::cout << "認識結果: " << outText << std::endl;
    delete[] outText;
    tess.End();
    return 0;
}

tess.Init(NULL, "jpn", tesseract::OEM_LSTM_ONLY);

# 例: tessdataフォルダにjpn.traineddataを配置

cp jpn.traineddata /usr/share/tesseract-ocr/4.00/tessdata/

#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>
#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat plateImg = cv::imread("plate_warped.jpg", cv::IMREAD_GRAYSCALE);
    if (plateImg.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    tesseract::TessBaseAPI tess;
    if (tess.Init(NULL, "jpn", tesseract::OEM_LSTM_ONLY)) {
        std::cerr << "Tesseractの初期化に失敗しました" << std::endl;
        return -1;
    }
    tess.SetPageSegMode(tesseract::PSM_SINGLE_LINE);
    tess.SetImage(plateImg.data, plateImg.cols, plateImg.rows, plateImg.channels(), plateImg.step);
    tess.Recognize(0);
    tesseract::ResultIterator* ri = tess.GetIterator();
    tesseract::PageIteratorLevel level = tesseract::RIL_SYMBOL;
    if (ri != nullptr) {
        do {
            const char* symbol = ri->GetUTF8Text(level);
            float conf = ri->Confidence(level);
            if (symbol != nullptr) {
                std::cout << "文字: " << symbol << " 信頼度: " << conf << std::endl;
                delete[] symbol;
            }
        } while (ri->Next(level));
    }
    tess.End();
    return 0;
}

#include <iostream>
#include <string>
// 全角数字・英字を半角に変換する簡易関数
std::string zenkakuToHankaku(const std::string& input) {
    std::string output;
    for (unsigned char c : input) {
        // 全角数字(0xFF10〜0xFF19)を半角に変換
        if (c >= 0xEF && c <= 0xEF) {
            // UTF-8の全角数字は3バイトなのでここでは簡易対応
            // 実際はUTF-8のマルチバイト処理が必要
            output += c; // ここは実装例のため省略
        } else if (c >= '0' && c <= '9') {
            output += c - '0' + '0';
        } else {
            output += c;
        }
    }
    return output;
}
int main() {
    std::string rawText = "1234あ56789";
    std::string normalized = zenkakuToHankaku(rawText);
    std::cout << "変換前: " << rawText << std::endl;
    std::cout << "変換後: " << normalized << std::endl;
    return 0;
}

変換前: 1234あ56789
変換後: 1234あ56789

#include <iostream>
#include <string>
#include <regex>
std::string insertHyphen(const std::string& input) {
    // 例: 分類番号(2〜3桁) + ひらがな + 登録番号(4桁)
    // ひらがなは1文字なので、その前後にハイフンを入れる例
    std::regex pattern(R"((\d{2,3})([あ-ん])(\d{4}))");
    std::string replaced = std::regex_replace(input, pattern, "$1-$2-$3");
    return replaced;
}
int main() {
    std::string rawText = "123あ4567";
    std::string withHyphen = insertHyphen(rawText);
    std::cout << "補完前: " << rawText << std::endl;
    std::cout << "補完後: " << withHyphen << std::endl;
    return 0;
}

補完前: 123あ4567
補完後: 123-あ-4567

#include <iostream>
#include <regex>
bool validatePlateFormat(const std::string& plate) {
    std::regex pattern(R"(^\d{2,3}-[あ-ん]-\d{4}$)");
    return std::regex_match(plate, pattern);
}
int main() {
    std::string plate1 = "123-あ-4567";
    std::string plate2 = "12-い-345";
    std::cout << plate1 << " は " << (validatePlateFormat(plate1) ? "有効" : "無効") << "な形式です。" << std::endl;
    std::cout << plate2 << " は " << (validatePlateFormat(plate2) ? "有効" : "無効") << "な形式です。" << std::endl;
    return 0;
}

123-あ-4567 は 有効な形式です。
12-い-345 は 無効な形式です。

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
std::string correctPrefectureName(const std::string& recognized, const std::vector<std::string>& prefectures) {
    // 簡易的に最も類似度の高い県名を返す(ここでは完全一致のみ)
    for (const auto& pref : prefectures) {
        if (recognized.find(pref) != std::string::npos) {
            return pref;
        }
    }
    return "不明";
}
int main() {
    std::vector<std::string> prefectures = {"東京", "大阪", "北海道", "福岡", "愛知"};
    std::string ocrResult = "東k京";
    std::string corrected = correctPrefectureName(ocrResult, prefectures);
    std::cout << "認識結果: " << ocrResult << " 補正後: " << corrected << std::endl;
    return 0;
}

認識結果: 東k京 補正後: 東京

#include <iostream>
#include <unordered_map>
#include <chrono>
#include <string>
class PlateFilter {
    std::unordered_map<std::string, std::chrono::steady_clock::time_point> lastSeen;
    std::chrono::seconds window;
public:
    PlateFilter(int seconds) : window(seconds) {}
    bool isNewPlate(const std::string& plate) {
        auto now = std::chrono::steady_clock::now();
        if (lastSeen.find(plate) == lastSeen.end() || now - lastSeen[plate] > window) {
            lastSeen[plate] = now;
            return true;
        }
        return false;
    }
};
int main() {
    PlateFilter filter(5); // 5秒間隔
    std::string plate = "123-あ-4567";
    if (filter.isNewPlate(plate)) {
        std::cout << "新しいナンバープレート: " << plate << std::endl;
    } else {
        std::cout << "重複ナンバープレート検出: " << plate << std::endl;
    }
    return 0;
}

#include <opencv2/opencv.hpp>
#include <omp.h>
#include <vector>
#include <iostream>
int main() {
    std::vector<cv::Mat> frames(10);
    // 例として同じ画像を複数用意
    cv::Mat img = cv::imread("plate.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    for (auto& f : frames) f = img.clone();
    std::vector<cv::Mat> results(frames.size());
    #pragma omp parallel for
    for (int i = 0; i < (int)frames.size(); ++i) {
        // 例えばガウシアンブラーを並列処理
        cv::GaussianBlur(frames[i], results[i], cv::Size(5,5), 0);
        std::cout << "Thread " << omp_get_thread_num() << " processed frame " << i << std::endl;
    }
    cv::imshow("Processed", results[0]);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <thread>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <iostream>
std::queue<cv::Mat> frameQueue;
std::mutex mtx;
std::condition_variable cv;
bool finished = false;
void worker() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !frameQueue.empty() || finished; });
        if (finished && frameQueue.empty()) break;
        cv::Mat frame = frameQueue.front();
        frameQueue.pop();
        lock.unlock();
        // ここで処理(例：前処理)
        cv::Mat processed;
        cv::GaussianBlur(frame, processed, cv::Size(5,5), 0);
        std::cout << "Processed a frame in thread " << std::this_thread::get_id() << std::endl;
    }
}
int main() {
    std::thread workerThread(worker);
    cv::Mat img = cv::imread("plate.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        frameQueue.push(img.clone());
        lock.unlock();
        cv.notify_one();
    }
    {
        std::unique_lock<std::mutex> lock(mtx);
        finished = true;
    }
    cv.notify_one();
    workerThread.join();
    return 0;
}

#include <opencv2/opencv.hpp>
#include <opencv2/cudafilters.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("plate.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::cuda::GpuMat d_img, d_blurred;
    d_img.upload(img);
    auto gaussianFilter = cv::cuda::createGaussianFilter(d_img.type(), d_blurred.type(), cv::Size(5,5), 0);
    gaussianFilter->apply(d_img, d_blurred);
    cv::Mat result;
    d_blurred.download(result);
    cv::imshow("CUDA Gaussian Blur", result);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
int main() {
    cv::Mat img = cv::imread("plate.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) return -1;
    cv::UMat u_img, u_blurred;
    img.copyTo(u_img);
    cv::GaussianBlur(u_img, u_blurred, cv::Size(5,5), 0);
    cv::Mat result = u_blurred.getMat(cv::ACCESS_READ);
    cv::imshow("OpenCL Gaussian Blur", result);
    cv::waitKey(0);
    return 0;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat frame = cv::imread("plate.jpg", cv::IMREAD_GRAYSCALE);
    if (frame.empty()) return -1;
    cv::Mat processed(frame.size(), frame.type());
    for (int i = 0; i < 100; ++i) {
        // processedを再利用して処理
        cv::GaussianBlur(frame, processed, cv::Size(5,5), 0);
        // 他の処理も同様にprocessedを使い回す
    }
    return 0;
}

#include <opencv2/opencv.hpp>
void processImage(cv::Mat& img) {
    for (int y = 0; y < img.rows; ++y) {
        uchar* rowPtr = img.ptr<uchar>(y);
        for (int x = 0; x < img.cols; ++x) {
            // 連続メモリアクセス
            rowPtr[x] = 255 - rowPtr[x]; // ネガポジ反転例
        }
    }
}

画像1: 正解「123-あ-4567」 認識「123-あ-4567」 → TP
画像2: 正解「12-い-3456」 認識「12-い-345」 → FN(誤認識)
画像3: 正解なし 認識「999-え-8888」 → FP(誤検出)

#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include <exception>
std::string performOCR(tesseract::TessBaseAPI& tess, const cv::Mat& img) {
    try {
        tess.SetImage(img.data, img.cols, img.rows, img.channels(), img.step);
        char* outText = tess.GetUTF8Text();
        if (!outText) {
            throw std::runtime_error("OCR結果が取得できませんでした");
        }
        std::string result(outText);
        delete[] outText;
        return result;
    } catch (const std::exception& e) {
        std::cerr << "OCR処理中に例外が発生しました: " << e.what() << std::endl;
        return "";
    }
}
int main() {
    tesseract::TessBaseAPI tess;
    if (tess.Init(NULL, "jpn", tesseract::OEM_LSTM_ONLY)) {
        std::cerr << "Tesseractの初期化に失敗しました" << std::endl;
        return -1;
    }
    cv::Mat img = cv::imread("plate_warped.jpg", cv::IMREAD_GRAYSCALE);
    if (img.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    std::string text = performOCR(tess, img);
    if (text.empty()) {
        std::cerr << "OCR結果が空です" << std::endl;
    } else {
        std::cout << "認識結果: " << text << std::endl;
    }
    tess.End();
    return 0;
}

#include <opencv2/opencv.hpp>
#include <iostream>
cv::Mat loadImageSafe(const std::string& path) {
    cv::Mat img = cv::imread(path);
    if (img.empty()) {
        std::cerr << "画像の読み込みに失敗しました: " << path << std::endl;
        // 代替処理として空のMatを返すか、デフォルト画像を返すことも可能
    }
    return img;
}
int main() {
    std::string imagePath = "nonexistent.jpg";
    cv::Mat img = loadImageSafe(imagePath);
    if (img.empty()) {
        std::cerr << "処理を中断します" << std::endl;
        return -1;
    }
    // 画像処理続行
    cv::imshow("Image", img);
    cv::waitKey(0);
    return 0;
}

#include <iostream>
#include <vector>
bool detectPlate(const cv::Mat& img, cv::Rect& plateRect) {
    // 仮の検出処理。実際は輪郭検出などを行う
    // ここでは失敗をシミュレート
    return false;
}
int main() {
    cv::Mat img = cv::imread("car.jpg");
    if (img.empty()) {
        std::cerr << "画像が読み込めません" << std::endl;
        return -1;
    }
    cv::Rect plateRect;
    bool detected = detectPlate(img, plateRect);
    if (!detected) {
        std::cerr << "ナンバープレートが検出できませんでした。再試行します。" << std::endl;
        // 例: 前処理パラメータを変えて再試行
        // ここでは再試行処理を省略
    } else {
        std::cout << "ナンバープレート検出成功: " << plateRect << std::endl;
    }
    return 0;
}

// 駐車場管理システムの簡易例(擬似コード)
std::string plateNumber = recognizePlate(frame);
if (isAuthorizedVehicle(plateNumber)) {
    openGate();
    logEntry(plateNumber, currentTime());
} else {
    alertSecurity(plateNumber);
}

POST /api/plate-recognition
Content-Type: application/json
{
  "plate_number": "123-あ-4567",
  "timestamp": "2024-06-01T12:34:56Z",
  "image_url": "https://example.com/images/plate123.jpg"
}

// マルチカメラの認識結果統合例(擬似コード)
std::vector<std::string> recognizedPlates;
for (auto& camera : cameras) {
    std::string plate = camera.recognizePlate();
    if (!plate.empty()) {
        recognizedPlates.push_back(plate);
    }
}
// 重複排除や信頼度評価を行う
std::string finalPlate = aggregateResults(recognizedPlates);

# 例: OpenCVのバージョン確認

pkg-config --modversion opencv4

再学習フロー例:

1. 誤認識データ収集 → 2. ラベリング → 3. ファインチューニング → 4. 検証 → 5. デプロイ

// ログ出力例(簡易)
#include <iostream>
#include <chrono>
#include <ctime>
void logRecognitionResult(const std::string& plate, bool success) {
    auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    std::cout << std::ctime(&now) << " 認識結果: " << plate << " 成功: " << (success ? "Yes" : "No") << std::endl;
}

#include <opencv2/opencv.hpp>
void maskPlate(cv::Mat& img, const cv::Rect& plateRect) {
    cv::Mat roi = img(plateRect);
    cv::Mat blurred;
    // モザイク処理：縮小して拡大
    cv::resize(roi, blurred, cv::Size(roi.cols / 10, roi.rows / 10), 0, 0, cv::INTER_LINEAR);
    cv::resize(blurred, blurred, roi.size(), 0, 0, cv::INTER_NEAREST);
    blurred.copyTo(roi);
}
int main() {
    cv::Mat img = cv::imread("car.jpg");
    if (img.empty()) return -1;
    cv::Rect plateRect(100, 200, 200, 50); // 例としてナンバープレート領域
    maskPlate(img, plateRect);
    cv::imshow("Masked Image", img);
    cv::waitKey(0);
    return 0;
}

// C++でのHTTPS通信はlibcurlなどを利用
#include <curl/curl.h>
#include <iostream>
int main() {
    CURL* curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://example.com/api/plate");
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L); // 証明書検証有効
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
        CURLcode res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            std::cerr << "通信エラー: " << curl_easy_strerror(res) << std::endl;
        }
        curl_easy_cleanup(curl);
    }
    return 0;
}