03 / C++
C++। মডেল থেকে ক্যামেরা।
লাইভ অ্যানোটেশন ও সীমিত ফ্রেম প্রসেসিংসহ আপনার ONNX ডিটেক্টর স্থানীয়ভাবে চালান।
উদাহরণগুলো নিয়ন্ত্রিত পরিবেশে বস্তু ও প্রাণী নিয়ে। মানুষের নজরদারি, পরিচয় শনাক্তকরণ বা আচরণ বিশ্লেষণ এর অন্তর্ভুক্ত নয়।
প্রকল্প তৈরি করুন
CMake ও OpenCV 4.x ইনস্টল করুন। সোর্স কোড বিল্ড করুন এবং টেস্ট চালান।
মূল বিষয়
cmake- নির্ভরতা কনফিগার করে এবং প্রজেক্ট কম্পাইল করে।
ctest- ক্যামেরা না খুলেই স্বয়ংক্রিয় পরীক্ষা চালায়।
unzip badbob-playground-cpp.zip
cd badbob-playground-cpp
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release --parallel
ctest --test-dir build -C Release --output-on-failureমডেল যুক্ত করুন
ক্যামেরা খোলার আগে মডেল ও লেবেল যাচাই করুন।
মূল বিষয়
read_labels(path)- মডেলের ক্লাসের ক্রমে নাম পড়ে; খালি বা পুনরাবৃত্ত লেবেল প্রত্যাখ্যান করে।
OpenCVDetector::detect(image)- ছবি প্রস্তুত করে, মডেল চালায় এবং শনাক্তকরণের ফল ফেরত দেয়।
মনে রাখুন
- লক্ষণ
- বক্স সরে যায় অথবা মডেল লোড হয় না।
- কারণ
- প্রিপ্রসেসিং, আউটপুট বিন্যাস বা লেবেলের ক্রম মেলে না।
- সমাধান
- এই অ্যাডাপ্টার শুধু নিচের চুক্তিটি সমর্থন করে। Core ML ফাইল ও অন্য ONNX আউটপুট বিন্যাসের জন্য আলাদা অ্যাডাপ্টার লাগে।
এই অ্যাডাপ্টার শুধু নিচের চুক্তিটি সমর্থন করে। Core ML ফাইল ও অন্য ONNX আউটপুট বিন্যাসের জন্য আলাদা অ্যাডাপ্টার লাগে।
বিস্তারিত
স্থানাঙ্ক 640×640 ইনপুট পিক্সেলে বক্সের কেন্দ্র ও আকার বোঝায়। লেবেলগুলো অবশ্যই মডেলের ক্লাসের সঠিক ক্রমে থাকতে হবে।
input:
color: RGB
dtype: float32
shape: [1, 3, 640, 640]
letterbox: 114
scale: 1/255
output:
dtype: float32
shape: [1, 4+C, N]
boxes: [cx, cy, width, height]
class_scores: probabilities
objectness: false
embedded_nms: false#include "badbob/opencv_detector.hpp"
#include <fstream>
#include <opencv2/imgproc.hpp>
#include <set>
#include <stdexcept>
namespace badbob {
std::vector<std::string> read_labels(const std::filesystem::path &path) {
std::ifstream input(path);
if (!input) {
throw std::invalid_argument("Cannot open labels file");
}
std::vector<std::string> labels;
std::set<std::string> unique;
std::string line;
while (std::getline(input, line)) {
const auto first = line.find_first_not_of(" \t\r"), last = line.find_last_not_of(" \t\r");
if (first == std::string::npos) {
throw std::invalid_argument("Labels must have no empty lines");
}
line = line.substr(first, last - first + 1);
if (line.size() > 120 || line.find_first_of("\n\t") != std::string::npos ||
!unique.insert(line).second) {
throw std::invalid_argument(
"Labels must be unique, single-line names of at most 120 bytes");
}
labels.push_back(line);
if (labels.size() > 1024) {
throw std::invalid_argument("At most 1024 classes are supported");
}
}
if (input.bad() || labels.empty()) {
throw std::invalid_argument("Cannot read nonempty labels file");
}
return labels;
}
OpenCVDetector::OpenCVDetector(const std::filesystem::path &model, std::size_t classes)
: classes_(classes) {
if (model.extension() != ".onnx" || !std::filesystem::is_regular_file(model) || classes == 0 ||
classes > 1024) {
throw std::invalid_argument("Provide an existing .onnx detector and 1–1024 labels");
}
network_ = cv::dnn::readNetFromONNX(model.string());
network_.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
network_.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
outputs_ = network_.getUnconnectedOutLayersNames();
if (outputs_.size() != 1) {
throw std::invalid_argument("Expected exactly one detector output");
}
// Fail before camera acquisition if the model cannot consume this exact input
// contract.
(void)detect(cv::Mat(640, 640, CV_8UC3, cv::Scalar(114, 114, 114)));
}
std::vector<Detection> OpenCVDetector::detect(const cv::Mat &image) {
if (image.empty() || image.type() != CV_8UC3) {
throw std::invalid_argument("Expected a nonempty 8-bit BGR image");
}
const auto t = letterbox({image.cols, image.rows});
cv::Mat resized;
cv::resize(image, resized, {t.resized.width, t.resized.height});
cv::Mat padded(t.edge, t.edge, CV_8UC3, cv::Scalar(114, 114, 114));
resized.copyTo(padded(cv::Rect(t.left, t.top, t.resized.width, t.resized.height)));
// RGB, NCHW float32, no crop. These values are part of the model contract.
const auto blob =
cv::dnn::blobFromImage(padded, 1.0 / 255.0, {640, 640}, {}, true, false, CV_32F);
network_.setInput(blob);
cv::Mat output = network_.forward(outputs_.front());
if (output.dims != 3 || output.type() != CV_32F || output.size[0] != 1 ||
output.size[1] != static_cast<int>(4 + classes_) || output.size[2] <= 0) {
throw std::invalid_argument("Expected float32[1,4+C,N], XYWH plus class "
"probabilities; no objectness or embedded NMS");
}
if (!output.isContinuous()) {
output = output.clone();
}
return decode({output.ptr<float>(), output.total()}, classes_,
static_cast<std::size_t>(output.size[2]), t);
}
} // namespace badbobক্যামেরা যুক্ত করুন
ক্যাপচার ও ইনফারেন্স একই ক্রমিক ওয়ার্কার থ্রেডে চলে। ইন্টারফেস শুধু সর্বশেষ সম্পূর্ণ প্রসেস করা ছবি ও তার শনাক্তকরণ পায়।
মূল বিষয়
Runner::run(...)- একটি ওয়ার্কার থ্রেডে ছবি গ্রহণ ও ইনফারেন্স পরিচালনা করে।
Runner::take()- সর্বশেষ সম্পূর্ণ প্রক্রিয়াকৃত ছবি ও তার শনাক্তকরণ নেয়; ফলাফল সারিতে জমতে পারে না।
মনে রাখুন
- লক্ষণ
- প্রিভিউ পিছিয়ে পড়ে এবং মেমোরির ব্যবহার বাড়ে।
- কারণ
- ইনফারেন্স যত দ্রুত ফ্রেম প্রক্রিয়া করে, ক্যামেরা তার চেয়ে দ্রুত ফ্রেম দেয়, ফলে সীমাহীন সারি বাড়তে থাকে।
- সমাধান
- ক্যাপচার ও ইনফারেন্স একই ক্রমিক ওয়ার্কার থ্রেডে চলে। ইন্টারফেস শুধু সর্বশেষ সম্পূর্ণ প্রসেস করা ছবি ও তার শনাক্তকরণ পায়।
বিস্তারিত
ডেস্ট্রাক্টর ~Runner() থামার অনুরোধ করে এবং ওয়ার্কার থ্রেডের জন্য অপেক্ষা করে। পরিষ্কার শেষ হওয়ার আগে চলমান OpenCV কলকে ফিরতে হবে।
#include "badbob/runner.hpp"
#include <exception>
#include <stdexcept>
#include <utility>
namespace badbob {
Runner::Runner(SourceFactory source, DetectorFactory detector)
: worker_(&Runner::run, this, std::move(source), std::move(detector)) {}
Runner::~Runner() {
stopped_.store(true);
// A backend read/forward may still be blocking. Never detach a live owner.
if (worker_.joinable()) {
worker_.join();
}
}
void Runner::run(SourceFactory source, DetectorFactory detector) noexcept {
try {
auto model = detector();
if (!model) {
throw std::runtime_error("Missing detector adapter");
}
if (stopped_.load()) {
return;
}
auto frames = source();
if (!frames) {
throw std::runtime_error("Missing capture adapter");
}
while (!stopped_.load()) {
auto image = frames->next();
if (stopped_.load()) {
break;
}
if (image.empty()) {
throw std::runtime_error("Camera returned an empty frame");
}
auto detections = model->detect(image);
if (stopped_.load()) {
break;
}
result_.publish({std::move(image), std::move(detections), {}});
}
} catch (const std::exception &error) {
if (!stopped_.load()) {
result_.publish({{}, {}, error.what()});
}
} catch (...) {
if (!stopped_.load()) {
result_.publish({{}, {}, "Unknown capture/inference failure"});
}
}
}
} // namespace badbobপূর্বাভাস সঠিক স্থানে বসান
letterbox স্কেলিং ও প্যাডিং ফিরিয়ে নিন, তারপর আঁকার আগে বক্সগুলো ছবির সীমানায় সীমিত করুন।
মূল বিষয়
letterbox(...) · unproject(...)- ছবির অনুপাত বজায় রাখে এবং বক্সকে মূল ছবির স্থানাঙ্কে ফিরিয়ে আনে।
decode(...)- পূর্বাভাস যাচাই করে এবং একই ক্লাসের ওভারল্যাপ করা বক্স সরায়।
মনে রাখুন
ছবির মাপ, ক্রপ, অভিমুখ ও স্থানাঙ্ককে একটিই চুক্তি হিসেবে ধরুন। চিহ্নে ভরসা করার আগে পরিচিত বাক্স দিয়ে পরীক্ষা করুন।
#include "badbob/detection.hpp"
#include <algorithm>
#include <cmath>
#include <limits>
#include <stdexcept>
namespace badbob {
namespace {
void validate(const Letterbox &t) {
if (t.original.width <= 0 || t.original.height <= 0 || t.resized.width <= 0 ||
t.resized.height <= 0 || t.edge <= 0 || t.resized.width > t.edge ||
t.resized.height > t.edge || t.left < 0 || t.top < 0 || t.left > t.edge - t.resized.width ||
t.top > t.edge - t.resized.height) {
throw std::invalid_argument("Invalid letterbox geometry");
}
}
double intersection_over_union(Box a, Box b) {
const double w = std::max(0.0, std::min(a.x + a.width, b.x + b.width) - std::max(a.x, b.x));
const double h = std::max(0.0, std::min(a.y + a.height, b.y + b.height) - std::max(a.y, b.y));
const double intersection = w * h;
const double area = a.width * a.height + b.width * b.height - intersection;
return area > 0 ? intersection / area : 0;
}
} // namespace
Letterbox letterbox(Size size, int edge) {
if (size.width <= 0 || size.height <= 0 || edge <= 0 || edge > 4096) {
throw std::invalid_argument(
"Image and input dimensions must be positive; input edge <=4096");
}
const double ratio = std::min(double(edge) / size.width, double(edge) / size.height);
const Size resized{std::max(1, int(std::lround(size.width * ratio))),
std::max(1, int(std::lround(size.height * ratio)))};
return {size, resized, (edge - resized.width) / 2, (edge - resized.height) / 2, edge};
}
Box unproject(Box b, const Letterbox &t) {
validate(t);
if (!std::isfinite(b.x) || !std::isfinite(b.y) || !std::isfinite(b.width) ||
!std::isfinite(b.height) || !std::isfinite(b.x + b.width) ||
!std::isfinite(b.y + b.height) || b.width < 0 || b.height < 0) {
throw std::invalid_argument("Box coordinates must be finite with nonnegative dimensions");
}
const auto x = [&](double v) {
return std::clamp((v - t.left) / t.resized.width, 0.0, 1.0) * t.original.width;
};
const auto y = [&](double v) {
return std::clamp((v - t.top) / t.resized.height, 0.0, 1.0) * t.original.height;
};
const double left = x(b.x), top = y(b.y);
return {left, top, x(b.x + b.width) - left, y(b.y + b.height) - top};
}
std::vector<Detection> decode(std::span<const float> data, std::size_t classes, std::size_t count,
const Letterbox &t, float confidence, float overlap) {
validate(t);
if (classes == 0 || classes > 1024 || count == 0 || count > 100000 ||
data.size() != (4 + classes) * count || !std::isfinite(confidence) ||
!std::isfinite(overlap) || confidence < 0 || confidence > 1 || overlap < 0 || overlap > 1) {
throw std::invalid_argument("Expected [1,4+C,N] probabilities, C<=1024, "
"N<=100000 and thresholds in [0,1]");
}
std::vector<Detection> candidates;
for (std::size_t i = 0; i < count; ++i) {
const double cx = data[i], cy = data[count + i], w = data[2 * count + i],
h = data[3 * count + i];
if (!std::isfinite(cx) || !std::isfinite(cy) || !std::isfinite(w) || !std::isfinite(h) ||
w < 0 || h < 0) {
throw std::invalid_argument("Unsupported detector coordinates");
}
float score = 0;
std::size_t label = 0;
for (std::size_t c = 0; c < classes; ++c) {
const float probability = data[(4 + c) * count + i];
if (!std::isfinite(probability) || probability < 0 || probability > 1) {
throw std::invalid_argument(
"Expected probabilities in [0,1], not logits/objectness");
}
if (probability > score) {
score = probability;
label = c;
}
}
if (score < confidence) {
continue;
}
const auto box = unproject({cx - w / 2, cy - h / 2, w, h}, t);
if (box.width > 0 && box.height > 0) {
candidates.push_back({box, label, score});
}
}
std::stable_sort(candidates.begin(), candidates.end(), [](const auto &a, const auto &b) {
return a.score > b.score;
});
// Bound quadratic suppression work; keep the highest-scoring candidates
// first.
if (candidates.size() > 3000) {
candidates.resize(3000);
}
std::vector<Detection> selected;
for (const auto &candidate : candidates) {
const bool suppressed =
std::any_of(selected.begin(), selected.end(), [&](const auto &previous) {
return previous.label == candidate.label &&
intersection_over_union(previous.box, candidate.box) > overlap;
});
if (!suppressed) {
selected.push_back(candidate);
}
if (selected.size() == 300) {
break;
}
}
return selected;
}
} // namespace badbobবিল্ড করুন। চালান। পরীক্ষা করুন।
ক্যামেরা স্পষ্টভাবে বেছে নিন অথবা অফলাইনে ছবি প্রসেস করুন। থামাতে Q বা Escape চাপুন।
মূল বিষয়
parse(argc, argv)- আর্গুমেন্ট যাচাই করে এবং ঠিক একটি ইনপুট বেছে নেয়: ছবি বা ক্যামেরা।
run_image(...) · run_camera(...)- নির্বাচিত পথ চালায়; ক্যামেরা মোড প্রক্রিয়াকরণ Runner-এর কাছে অর্পণ করে।
মনে রাখুন
- লক্ষণ
- থামতে প্রত্যাশার চেয়ে বেশি সময় লাগছে।
- কারণ
- OpenCV-এর ক্যাপচার বা ইনফারেন্স কল এখনও ব্লক করছে।
- সমাধান
- থামার অনুরোধ করুন, নতুন ফল প্রত্যাখ্যান করুন এবং ওয়ার্কার শেষ হওয়ার অপেক্ষা করুন। ব্যাকএন্ড টাইমআউটের জন্য প্ল্যাটফর্ম সমর্থন দরকার; সক্রিয় রিসোর্সসহ থ্রেড বিচ্ছিন্ন করবেন না।
বিস্তারিত
write_new_png() একচেটিয়াভাবে নতুন ফাইল তৈরি করে; বিদ্যমান ফাইল কখনও ওভাররাইট করে না।
./build/badbob-camera --model detector.onnx --labels labels.txt --image frame.png --output result.png
./build/badbob-camera --model detector.onnx --labels labels.txt --camera 003.06 / ভালো চর্চা
ছোট খুঁটিনাটি। ভালো উদাহরণ।
- ক্যাপচার ও ইনফারেন্স UI থ্রেডের বাইরে রাখুন। পুরোনো ফ্রেম জমতে না দিয়ে সারির সীমা নির্ধারণ করুন।
- ছবির মাপ, ক্রপ, অভিমুখ ও স্থানাঙ্ককে একটিই চুক্তি হিসেবে ধরুন। চিহ্নে ভরসা করার আগে পরিচিত বাক্স দিয়ে পরীক্ষা করুন।
- থামার অনুরোধ করুন, নতুন ফল প্রত্যাখ্যান করুন এবং ওয়ার্কার শেষ হওয়ার অপেক্ষা করুন। ব্যাকএন্ড টাইমআউটের জন্য প্ল্যাটফর্ম সমর্থন দরকার; সক্রিয় রিসোর্সসহ থ্রেড বিচ্ছিন্ন করবেন না।