chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,91 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/aruco_detector.hpp>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
#include <ctime>
|
||||
|
||||
namespace {
|
||||
inline static bool readCameraParameters(const std::string& filename, cv::Mat &camMatrix, cv::Mat &distCoeffs) {
|
||||
cv::FileStorage fs(filename, cv::FileStorage::READ);
|
||||
if (!fs.isOpened())
|
||||
return false;
|
||||
fs["camera_matrix"] >> camMatrix;
|
||||
fs["distortion_coefficients"] >> distCoeffs;
|
||||
return true;
|
||||
}
|
||||
|
||||
inline static bool saveCameraParams(const std::string &filename, cv::Size imageSize, float aspectRatio, int flags,
|
||||
const cv::Mat &cameraMatrix, const cv::Mat &distCoeffs, double totalAvgErr) {
|
||||
cv::FileStorage fs(filename, cv::FileStorage::WRITE);
|
||||
if (!fs.isOpened())
|
||||
return false;
|
||||
|
||||
time_t tt;
|
||||
time(&tt);
|
||||
struct tm *t2 = localtime(&tt);
|
||||
char buf[1024];
|
||||
strftime(buf, sizeof(buf) - 1, "%c", t2);
|
||||
|
||||
fs << "calibration_time" << buf;
|
||||
fs << "image_width" << imageSize.width;
|
||||
fs << "image_height" << imageSize.height;
|
||||
|
||||
if (flags & cv::CALIB_FIX_ASPECT_RATIO) fs << "aspectRatio" << aspectRatio;
|
||||
|
||||
if (flags != 0) {
|
||||
snprintf(buf, sizeof(buf), "flags: %s%s%s%s",
|
||||
flags & cv::CALIB_USE_INTRINSIC_GUESS ? "+use_intrinsic_guess" : "",
|
||||
flags & cv::CALIB_FIX_ASPECT_RATIO ? "+fix_aspectRatio" : "",
|
||||
flags & cv::CALIB_FIX_PRINCIPAL_POINT ? "+fix_principal_point" : "",
|
||||
flags & cv::CALIB_ZERO_TANGENT_DIST ? "+zero_tangent_dist" : "");
|
||||
}
|
||||
fs << "flags" << flags;
|
||||
fs << "camera_matrix" << cameraMatrix;
|
||||
fs << "distortion_coefficients" << distCoeffs;
|
||||
fs << "avg_reprojection_error" << totalAvgErr;
|
||||
return true;
|
||||
}
|
||||
|
||||
inline static cv::aruco::DetectorParameters readDetectorParamsFromCommandLine(cv::CommandLineParser &parser) {
|
||||
cv::aruco::DetectorParameters detectorParams;
|
||||
if (parser.has("dp")) {
|
||||
cv::FileStorage fs(parser.get<std::string>("dp"), cv::FileStorage::READ);
|
||||
bool readOk = detectorParams.readDetectorParameters(fs.root());
|
||||
if(!readOk) {
|
||||
throw std::runtime_error("Invalid detector parameters file\n");
|
||||
}
|
||||
}
|
||||
return detectorParams;
|
||||
}
|
||||
|
||||
inline static void readCameraParamsFromCommandLine(cv::CommandLineParser &parser, cv::Mat& camMatrix, cv::Mat& distCoeffs) {
|
||||
//! [camDistCoeffs]
|
||||
if(parser.has("c")) {
|
||||
bool readOk = readCameraParameters(parser.get<std::string>("c"), camMatrix, distCoeffs);
|
||||
if(!readOk) {
|
||||
throw std::runtime_error("Invalid camera file\n");
|
||||
}
|
||||
}
|
||||
//! [camDistCoeffs]
|
||||
}
|
||||
|
||||
inline static cv::aruco::Dictionary readDictionatyFromCommandLine(cv::CommandLineParser &parser) {
|
||||
cv::aruco::Dictionary dictionary;
|
||||
if (parser.has("cd")) {
|
||||
cv::FileStorage fs(parser.get<std::string>("cd"), cv::FileStorage::READ);
|
||||
bool readOk = dictionary.readDictionary(fs.root());
|
||||
if(!readOk) {
|
||||
throw std::runtime_error("Invalid dictionary file\n");
|
||||
}
|
||||
}
|
||||
else {
|
||||
int dictionaryId = parser.has("d") ? parser.get<int>("d"): cv::aruco::DICT_4X4_50;
|
||||
if (!parser.has("d")) {
|
||||
std::cout << "The default DICT_4X4_50 dictionary has been selected, you could "
|
||||
"select the specific dictionary using flags -d or -cd." << std::endl;
|
||||
}
|
||||
dictionary = cv::aruco::getPredefinedDictionary(dictionaryId);
|
||||
}
|
||||
return dictionary;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
#include <ctime>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/objdetect/aruco_detector.hpp>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
|
||||
namespace {
|
||||
const char* about =
|
||||
"Calibration using a ArUco Planar Grid board\n"
|
||||
" To capture a frame for calibration, press 'c',\n"
|
||||
" If input comes from video, press any key for next frame\n"
|
||||
" To finish capturing, press 'ESC' key and calibration starts.\n";
|
||||
const char* keys =
|
||||
"{w | | Number of squares in X direction }"
|
||||
"{h | | Number of squares in Y direction }"
|
||||
"{l | | Marker side length (in meters) }"
|
||||
"{s | | Separation between two consecutive markers in the grid (in meters) }"
|
||||
"{d | | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{@outfile |cam.yml| Output file with calibrated camera parameters }"
|
||||
"{v | | Input from video file, if ommited, input comes from camera }"
|
||||
"{ci | 0 | Camera id if input doesnt come from video (-v) }"
|
||||
"{dp | | File of marker detector parameters }"
|
||||
"{rs | false | Apply refind strategy }"
|
||||
"{zt | false | Assume zero tangential distortion }"
|
||||
"{a | | Fix aspect ratio (fx/fy) to this value }"
|
||||
"{pc | false | Fix the principal point at the center }";
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
if(argc < 6) {
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int markersX = parser.get<int>("w");
|
||||
int markersY = parser.get<int>("h");
|
||||
float markerLength = parser.get<float>("l");
|
||||
float markerSeparation = parser.get<float>("s");
|
||||
string outputFile = parser.get<string>(0);
|
||||
|
||||
int calibrationFlags = 0;
|
||||
float aspectRatio = 1;
|
||||
if(parser.has("a")) {
|
||||
calibrationFlags |= CALIB_FIX_ASPECT_RATIO;
|
||||
aspectRatio = parser.get<float>("a");
|
||||
}
|
||||
if(parser.get<bool>("zt")) calibrationFlags |= CALIB_ZERO_TANGENT_DIST;
|
||||
if(parser.get<bool>("pc")) calibrationFlags |= CALIB_FIX_PRINCIPAL_POINT;
|
||||
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
|
||||
|
||||
bool refindStrategy = parser.get<bool>("rs");
|
||||
int camId = parser.get<int>("ci");
|
||||
String video;
|
||||
|
||||
if(parser.has("v")) {
|
||||
video = parser.get<String>("v");
|
||||
}
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
VideoCapture inputVideo;
|
||||
int waitTime;
|
||||
if(!video.empty()) {
|
||||
inputVideo.open(video);
|
||||
waitTime = 0;
|
||||
} else {
|
||||
inputVideo.open(camId);
|
||||
waitTime = 10;
|
||||
}
|
||||
|
||||
//! [CalibrationWithArucoBoard1]
|
||||
// Create board object and ArucoDetector
|
||||
aruco::GridBoard gridboard(Size(markersX, markersY), markerLength, markerSeparation, dictionary);
|
||||
aruco::ArucoDetector detector(dictionary, detectorParams);
|
||||
|
||||
// Collected frames for calibration
|
||||
vector<vector<vector<Point2f>>> allMarkerCorners;
|
||||
vector<vector<int>> allMarkerIds;
|
||||
Size imageSize;
|
||||
|
||||
while(inputVideo.grab()) {
|
||||
Mat image, imageCopy;
|
||||
inputVideo.retrieve(image);
|
||||
|
||||
vector<int> markerIds;
|
||||
vector<vector<Point2f>> markerCorners, rejectedMarkers;
|
||||
|
||||
// Detect markers
|
||||
detector.detectMarkers(image, markerCorners, markerIds, rejectedMarkers);
|
||||
|
||||
// Refind strategy to detect more markers
|
||||
if(refindStrategy) {
|
||||
detector.refineDetectedMarkers(image, gridboard, markerCorners, markerIds, rejectedMarkers);
|
||||
}
|
||||
//! [CalibrationWithArucoBoard1]
|
||||
|
||||
// Draw results
|
||||
image.copyTo(imageCopy);
|
||||
|
||||
if(!markerIds.empty()) {
|
||||
aruco::drawDetectedMarkers(imageCopy, markerCorners, markerIds);
|
||||
}
|
||||
|
||||
putText(imageCopy, "Press 'c' to add current frame. 'ESC' to finish and calibrate",
|
||||
Point(10, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 0), 2);
|
||||
imshow("out", imageCopy);
|
||||
|
||||
// Wait for key pressed
|
||||
char key = (char)waitKey(waitTime);
|
||||
|
||||
if(key == 27) {
|
||||
break;
|
||||
}
|
||||
|
||||
//! [CalibrationWithArucoBoard2]
|
||||
if(key == 'c' && !markerIds.empty()) {
|
||||
cout << "Frame captured" << endl;
|
||||
allMarkerCorners.push_back(markerCorners);
|
||||
allMarkerIds.push_back(markerIds);
|
||||
imageSize = image.size();
|
||||
}
|
||||
}
|
||||
//! [CalibrationWithArucoBoard2]
|
||||
|
||||
if(allMarkerIds.empty()) {
|
||||
throw std::runtime_error("Not enough captures for calibration\n");
|
||||
}
|
||||
|
||||
//! [CalibrationWithArucoBoard3]
|
||||
Mat cameraMatrix, distCoeffs;
|
||||
|
||||
if(calibrationFlags & CALIB_FIX_ASPECT_RATIO) {
|
||||
cameraMatrix = Mat::eye(3, 3, CV_64F);
|
||||
cameraMatrix.at<double>(0, 0) = aspectRatio;
|
||||
}
|
||||
|
||||
// Prepare data for calibration
|
||||
vector<Point3f> objectPoints;
|
||||
vector<Point2f> imagePoints;
|
||||
vector<Mat> processedObjectPoints, processedImagePoints;
|
||||
size_t nFrames = allMarkerCorners.size();
|
||||
|
||||
for(size_t frame = 0; frame < nFrames; frame++) {
|
||||
Mat currentImgPoints, currentObjPoints;
|
||||
|
||||
gridboard.matchImagePoints(allMarkerCorners[frame], allMarkerIds[frame], currentObjPoints, currentImgPoints);
|
||||
|
||||
if(currentImgPoints.total() > 0 && currentObjPoints.total() > 0) {
|
||||
processedImagePoints.push_back(currentImgPoints);
|
||||
processedObjectPoints.push_back(currentObjPoints);
|
||||
}
|
||||
}
|
||||
|
||||
// Calibrate camera
|
||||
double repError = calibrateCamera(processedObjectPoints, processedImagePoints, imageSize, cameraMatrix, distCoeffs,
|
||||
noArray(), noArray(), noArray(), noArray(), noArray(), calibrationFlags);
|
||||
//! [CalibrationWithArucoBoard3]
|
||||
bool saveOk = saveCameraParams(outputFile, imageSize, aspectRatio, calibrationFlags,
|
||||
cameraMatrix, distCoeffs, repError);
|
||||
|
||||
if(!saveOk) {
|
||||
throw std::runtime_error("Cannot save output file\n");
|
||||
}
|
||||
|
||||
cout << "Rep Error: " << repError << endl;
|
||||
cout << "Calibration saved to " << outputFile << endl;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <opencv2/calib3d.hpp>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/imgproc.hpp>
|
||||
#include <opencv2/objdetect/charuco_detector.hpp>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about =
|
||||
"Calibration using a ChArUco board\n"
|
||||
" To capture a frame for calibration, press 'c',\n"
|
||||
" If input comes from video, press any key for next frame\n"
|
||||
" To finish capturing, press 'ESC' key and calibration starts.\n";
|
||||
const char* keys =
|
||||
"{w | | Number of squares in X direction }"
|
||||
"{h | | Number of squares in Y direction }"
|
||||
"{sl | | Square side length (in meters) }"
|
||||
"{ml | | Marker side length (in meters) }"
|
||||
"{d | | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{@outfile |cam.yml| Output file with calibrated camera parameters }"
|
||||
"{v | | Input from video file, if ommited, input comes from camera }"
|
||||
"{ci | 0 | Camera id if input doesnt come from video (-v) }"
|
||||
"{dp | | File of marker detector parameters }"
|
||||
"{rs | false | Apply refind strategy }"
|
||||
"{zt | false | Assume zero tangential distortion }"
|
||||
"{a | | Fix aspect ratio (fx/fy) to this value }"
|
||||
"{pc | false | Fix the principal point at the center }"
|
||||
"{sc | false | Show detected chessboard corners after calibration }";
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
if(argc < 7) {
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int squaresX = parser.get<int>("w");
|
||||
int squaresY = parser.get<int>("h");
|
||||
float squareLength = parser.get<float>("sl");
|
||||
float markerLength = parser.get<float>("ml");
|
||||
string outputFile = parser.get<string>(0);
|
||||
|
||||
bool showChessboardCorners = parser.get<bool>("sc");
|
||||
|
||||
int calibrationFlags = 0;
|
||||
float aspectRatio = 1;
|
||||
if(parser.has("a")) {
|
||||
calibrationFlags |= CALIB_FIX_ASPECT_RATIO;
|
||||
aspectRatio = parser.get<float>("a");
|
||||
}
|
||||
if(parser.get<bool>("zt")) calibrationFlags |= CALIB_ZERO_TANGENT_DIST;
|
||||
if(parser.get<bool>("pc")) calibrationFlags |= CALIB_FIX_PRINCIPAL_POINT;
|
||||
|
||||
aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
|
||||
bool refindStrategy = parser.get<bool>("rs");
|
||||
int camId = parser.get<int>("ci");
|
||||
String video;
|
||||
|
||||
if(parser.has("v")) {
|
||||
video = parser.get<String>("v");
|
||||
}
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
VideoCapture inputVideo;
|
||||
int waitTime;
|
||||
if(!video.empty()) {
|
||||
inputVideo.open(video);
|
||||
waitTime = 0;
|
||||
} else {
|
||||
inputVideo.open(camId);
|
||||
waitTime = 10;
|
||||
}
|
||||
|
||||
aruco::CharucoParameters charucoParams;
|
||||
if(refindStrategy) {
|
||||
charucoParams.tryRefineMarkers = true;
|
||||
}
|
||||
|
||||
//! [CalibrationWithCharucoBoard1]
|
||||
// Create charuco board object and CharucoDetector
|
||||
aruco::CharucoBoard board(Size(squaresX, squaresY), squareLength, markerLength, dictionary);
|
||||
aruco::CharucoDetector detector(board, charucoParams, detectorParams);
|
||||
|
||||
// Collect data from each frame
|
||||
vector<Mat> allCharucoCorners, allCharucoIds;
|
||||
|
||||
vector<vector<Point2f>> allImagePoints;
|
||||
vector<vector<Point3f>> allObjectPoints;
|
||||
|
||||
vector<Mat> allImages;
|
||||
Size imageSize;
|
||||
|
||||
while(inputVideo.grab()) {
|
||||
Mat image, imageCopy;
|
||||
inputVideo.retrieve(image);
|
||||
|
||||
vector<int> markerIds;
|
||||
vector<vector<Point2f>> markerCorners;
|
||||
Mat currentCharucoCorners, currentCharucoIds;
|
||||
vector<Point3f> currentObjectPoints;
|
||||
vector<Point2f> currentImagePoints;
|
||||
|
||||
// Detect ChArUco board
|
||||
detector.detectBoard(image, currentCharucoCorners, currentCharucoIds);
|
||||
//! [CalibrationWithCharucoBoard1]
|
||||
|
||||
// Draw results
|
||||
image.copyTo(imageCopy);
|
||||
if(!markerIds.empty()) {
|
||||
aruco::drawDetectedMarkers(imageCopy, markerCorners);
|
||||
}
|
||||
|
||||
if(currentCharucoCorners.total() > 3) {
|
||||
aruco::drawDetectedCornersCharuco(imageCopy, currentCharucoCorners, currentCharucoIds);
|
||||
}
|
||||
|
||||
putText(imageCopy, "Press 'c' to add current frame. 'ESC' to finish and calibrate",
|
||||
Point(10, 20), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 0, 0), 2);
|
||||
|
||||
imshow("out", imageCopy);
|
||||
|
||||
// Wait for key pressed
|
||||
char key = (char)waitKey(waitTime);
|
||||
|
||||
if(key == 27) {
|
||||
break;
|
||||
}
|
||||
|
||||
//! [CalibrationWithCharucoBoard2]
|
||||
if(key == 'c' && currentCharucoCorners.total() > 3) {
|
||||
// Match image points
|
||||
board.matchImagePoints(currentCharucoCorners, currentCharucoIds, currentObjectPoints, currentImagePoints);
|
||||
|
||||
if(currentImagePoints.empty() || currentObjectPoints.empty()) {
|
||||
cout << "Point matching failed, try again." << endl;
|
||||
continue;
|
||||
}
|
||||
|
||||
cout << "Frame captured" << endl;
|
||||
|
||||
allCharucoCorners.push_back(currentCharucoCorners);
|
||||
allCharucoIds.push_back(currentCharucoIds);
|
||||
allImagePoints.push_back(currentImagePoints);
|
||||
allObjectPoints.push_back(currentObjectPoints);
|
||||
allImages.push_back(image);
|
||||
|
||||
imageSize = image.size();
|
||||
}
|
||||
}
|
||||
//! [CalibrationWithCharucoBoard2]
|
||||
|
||||
if(allCharucoCorners.size() < 4) {
|
||||
cerr << "Not enough corners for calibration" << endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//! [CalibrationWithCharucoBoard3]
|
||||
Mat cameraMatrix, distCoeffs;
|
||||
|
||||
if(calibrationFlags & CALIB_FIX_ASPECT_RATIO) {
|
||||
cameraMatrix = Mat::eye(3, 3, CV_64F);
|
||||
cameraMatrix.at<double>(0, 0) = aspectRatio;
|
||||
}
|
||||
|
||||
// Calibrate camera using ChArUco
|
||||
double repError = calibrateCamera(allObjectPoints, allImagePoints, imageSize, cameraMatrix, distCoeffs,
|
||||
noArray(), noArray(), noArray(), noArray(), noArray(), calibrationFlags);
|
||||
//! [CalibrationWithCharucoBoard3]
|
||||
|
||||
bool saveOk = saveCameraParams(outputFile, imageSize, aspectRatio, calibrationFlags,
|
||||
cameraMatrix, distCoeffs, repError);
|
||||
|
||||
if(!saveOk) {
|
||||
cerr << "Cannot save output file" << endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
cout << "Rep Error: " << repError << endl;
|
||||
cout << "Calibration saved to " << outputFile << endl;
|
||||
|
||||
// Show interpolated charuco corners for debugging
|
||||
if(showChessboardCorners) {
|
||||
for(size_t frame = 0; frame < allImages.size(); frame++) {
|
||||
Mat imageCopy = allImages[frame].clone();
|
||||
|
||||
if(allCharucoCorners[frame].total() > 0) {
|
||||
aruco::drawDetectedCornersCharuco(imageCopy, allCharucoCorners[frame], allCharucoIds[frame]);
|
||||
}
|
||||
|
||||
imshow("out", imageCopy);
|
||||
char key = (char)waitKey(0);
|
||||
if(key == 27) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/aruco_detector.hpp>
|
||||
#include <iostream>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Create an ArUco grid board image";
|
||||
const char* keys =
|
||||
"{@outfile |<none> | Output image }"
|
||||
"{w | | Number of markers in X direction }"
|
||||
"{h | | Number of markers in Y direction }"
|
||||
"{l | | Marker side length (in pixels) }"
|
||||
"{s | | Separation between two consecutive markers in the grid (in pixels)}"
|
||||
"{d | | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{m | | Margins size (in pixels). Default is marker separation (-s) }"
|
||||
"{bb | 1 | Number of bits in marker borders }"
|
||||
"{si | false | show generated image }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
if(argc < 7) {
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int markersX = parser.get<int>("w");
|
||||
int markersY = parser.get<int>("h");
|
||||
int markerLength = parser.get<int>("l");
|
||||
int markerSeparation = parser.get<int>("s");
|
||||
int margins = markerSeparation;
|
||||
if(parser.has("m")) {
|
||||
margins = parser.get<int>("m");
|
||||
}
|
||||
|
||||
int borderBits = parser.get<int>("bb");
|
||||
bool showImage = parser.get<bool>("si");
|
||||
|
||||
String out = parser.get<String>(0);
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Size imageSize;
|
||||
imageSize.width = markersX * (markerLength + markerSeparation) - markerSeparation + 2 * margins;
|
||||
imageSize.height =
|
||||
markersY * (markerLength + markerSeparation) - markerSeparation + 2 * margins;
|
||||
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
aruco::GridBoard board(Size(markersX, markersY), float(markerLength), float(markerSeparation), dictionary);
|
||||
|
||||
// show created board
|
||||
//! [aruco_generate_board_image]
|
||||
Mat boardImage;
|
||||
board.generateImage(imageSize, boardImage, margins, borderBits);
|
||||
//! [aruco_generate_board_image]
|
||||
|
||||
if(showImage) {
|
||||
imshow("board", boardImage);
|
||||
waitKey(0);
|
||||
}
|
||||
|
||||
imwrite(out, boardImage);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/charuco_detector.hpp>
|
||||
#include <iostream>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Create a ChArUco board image";
|
||||
//! [charuco_detect_board_keys]
|
||||
const char* keys =
|
||||
"{@outfile |res.png| Output image }"
|
||||
"{w | 5 | Number of squares in X direction }"
|
||||
"{h | 7 | Number of squares in Y direction }"
|
||||
"{sl | 100 | Square side length (in pixels) }"
|
||||
"{ml | 60 | Marker side length (in pixels) }"
|
||||
"{d | | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{m | | Margins size (in pixels). Default is (squareLength-markerLength) }"
|
||||
"{bb | 1 | Number of bits in marker borders }"
|
||||
"{si | false | show generated image }";
|
||||
}
|
||||
//! [charuco_detect_board_keys]
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
if (argc == 1) {
|
||||
parser.printMessage();
|
||||
}
|
||||
|
||||
int squaresX = parser.get<int>("w");
|
||||
int squaresY = parser.get<int>("h");
|
||||
int squareLength = parser.get<int>("sl");
|
||||
int markerLength = parser.get<int>("ml");
|
||||
int margins = squareLength - markerLength;
|
||||
if(parser.has("m")) {
|
||||
margins = parser.get<int>("m");
|
||||
}
|
||||
|
||||
int borderBits = parser.get<int>("bb");
|
||||
bool showImage = parser.get<bool>("si");
|
||||
|
||||
std::string pathOutImg = parser.get<std::string>(0);
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
//! [create_charucoBoard]
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
cv::aruco::CharucoBoard board(Size(squaresX, squaresY), (float)squareLength, (float)markerLength, dictionary);
|
||||
//! [create_charucoBoard]
|
||||
|
||||
// show created board
|
||||
//! [generate_charucoBoard]
|
||||
Mat boardImage;
|
||||
Size imageSize;
|
||||
imageSize.width = squaresX * squareLength + 2 * margins;
|
||||
imageSize.height = squaresY * squareLength + 2 * margins;
|
||||
board.generateImage(imageSize, boardImage, margins, borderBits);
|
||||
//! [generate_charucoBoard]
|
||||
|
||||
if(showImage) {
|
||||
imshow("board", boardImage);
|
||||
waitKey(0);
|
||||
}
|
||||
|
||||
if (pathOutImg != "")
|
||||
imwrite(pathOutImg, boardImage);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/charuco_detector.hpp>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Create a ChArUco marker image";
|
||||
const char* keys =
|
||||
"{@outfile | res.png | Output image }"
|
||||
"{sl | 100 | Square side length (in pixels) }"
|
||||
"{ml | 60 | Marker side length (in pixels) }"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{d | 10 | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{ids |0, 1, 2, 3 | Four ids for the ChArUco marker: id1,id2,id3,id4 }"
|
||||
"{m | 0 | Margins size (in pixels) }"
|
||||
"{bb | 1 | Number of bits in marker borders }"
|
||||
"{si | false | show generated image }";
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
int squareLength = parser.get<int>("sl");
|
||||
int markerLength = parser.get<int>("ml");
|
||||
string idsString = parser.get<string>("ids");
|
||||
int margins = parser.get<int>("m");
|
||||
int borderBits = parser.get<int>("bb");
|
||||
bool showImage = parser.get<bool>("si");
|
||||
string out = parser.get<string>(0);
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
istringstream ss(idsString);
|
||||
vector<string> splittedIds;
|
||||
string token;
|
||||
while(getline(ss, token, ','))
|
||||
splittedIds.push_back(token);
|
||||
if(splittedIds.size() < 4) {
|
||||
throw std::runtime_error("Incorrect ids format\n");
|
||||
}
|
||||
Vec4i ids;
|
||||
for(int i = 0; i < 4; i++)
|
||||
ids[i] = atoi(splittedIds[i].c_str());
|
||||
|
||||
//! [generate_diamond]
|
||||
vector<int> diamondIds = {ids[0], ids[1], ids[2], ids[3]};
|
||||
aruco::CharucoBoard charucoBoard(Size(3, 3), (float)squareLength, (float)markerLength, dictionary, diamondIds);
|
||||
Mat markerImg;
|
||||
charucoBoard.generateImage(Size(3*squareLength + 2*margins, 3*squareLength + 2*margins), markerImg, margins, borderBits);
|
||||
//! [generate_diamond]
|
||||
|
||||
if(showImage) {
|
||||
imshow("board", markerImg);
|
||||
waitKey(0);
|
||||
}
|
||||
|
||||
if (out != "")
|
||||
imwrite(out, markerImg);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/aruco_detector.hpp>
|
||||
#include <iostream>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Create an ArUco/AprilTag marker image";
|
||||
|
||||
//! [aruco_create_markers_keys]
|
||||
const char* keys =
|
||||
"{@outfile |res.png| Output image }"
|
||||
"{d | 0 | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{id | 0 | Marker id in the dictionary }"
|
||||
"{ms | 200 | Marker size in pixels }"
|
||||
"{bb | 1 | Number of bits in marker borders }"
|
||||
"{si | false | show generated image }";
|
||||
}
|
||||
//! [aruco_create_markers_keys]
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
int markerId = parser.get<int>("id");
|
||||
int borderBits = parser.get<int>("bb");
|
||||
int markerSize = parser.get<int>("ms");
|
||||
bool showImage = parser.get<bool>("si");
|
||||
|
||||
String out = parser.get<String>(0);
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
|
||||
Mat markerImg;
|
||||
aruco::generateImageMarker(dictionary, markerId, markerSize, markerImg, borderBits);
|
||||
|
||||
if(showImage) {
|
||||
imshow("marker", markerImg);
|
||||
waitKey(0);
|
||||
}
|
||||
|
||||
imwrite(out, markerImg);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/aruco_detector.hpp>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Pose estimation using a ArUco Planar Grid board";
|
||||
|
||||
//! [aruco_detect_board_keys]
|
||||
const char* keys =
|
||||
"{w | | Number of squares in X direction }"
|
||||
"{h | | Number of squares in Y direction }"
|
||||
"{l | | Marker side length (in pixels) }"
|
||||
"{s | | Separation between two consecutive markers in the grid (in pixels)}"
|
||||
"{d | | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{c | | Output file with calibrated camera parameters }"
|
||||
"{v | | Input from video or image file, if omitted, input comes from camera }"
|
||||
"{ci | 0 | Camera id if input doesnt come from video (-v) }"
|
||||
"{dp | | File of marker detector parameters }"
|
||||
"{rs | | Apply refind strategy }"
|
||||
"{r | | show rejected candidates too }";
|
||||
}
|
||||
//! [aruco_detect_board_keys]
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
if(argc < 7) {
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
//! [aruco_detect_board_full_sample]
|
||||
int markersX = parser.get<int>("w");
|
||||
int markersY = parser.get<int>("h");
|
||||
float markerLength = parser.get<float>("l");
|
||||
float markerSeparation = parser.get<float>("s");
|
||||
bool showRejected = parser.has("r");
|
||||
bool refindStrategy = parser.has("rs");
|
||||
int camId = parser.get<int>("ci");
|
||||
|
||||
|
||||
Mat camMatrix, distCoeffs;
|
||||
readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
|
||||
|
||||
String video;
|
||||
if(parser.has("v")) {
|
||||
video = parser.get<String>("v");
|
||||
}
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
aruco::ArucoDetector detector(dictionary, detectorParams);
|
||||
VideoCapture inputVideo;
|
||||
int waitTime;
|
||||
if(!video.empty()) {
|
||||
inputVideo.open(video);
|
||||
waitTime = 0;
|
||||
} else {
|
||||
inputVideo.open(camId);
|
||||
waitTime = 10;
|
||||
}
|
||||
|
||||
float axisLength = 0.5f * ((float)min(markersX, markersY) * (markerLength + markerSeparation) +
|
||||
markerSeparation);
|
||||
|
||||
// Create GridBoard object
|
||||
//! [aruco_create_board]
|
||||
aruco::GridBoard board(Size(markersX, markersY), markerLength, markerSeparation, dictionary);
|
||||
//! [aruco_create_board]
|
||||
|
||||
// Also you could create Board object
|
||||
//vector<vector<Point3f> > objPoints; // array of object points of all the marker corners in the board
|
||||
//vector<int> ids; // vector of the identifiers of the markers in the board
|
||||
//aruco::Board board(objPoints, dictionary, ids);
|
||||
|
||||
double totalTime = 0;
|
||||
int totalIterations = 0;
|
||||
|
||||
while(inputVideo.grab()) {
|
||||
Mat image, imageCopy;
|
||||
inputVideo.retrieve(image);
|
||||
|
||||
double tick = (double)getTickCount();
|
||||
|
||||
vector<int> ids;
|
||||
vector<vector<Point2f>> corners, rejected;
|
||||
Vec3d rvec, tvec;
|
||||
|
||||
//! [aruco_detect_and_refine]
|
||||
|
||||
// Detect markers
|
||||
detector.detectMarkers(image, corners, ids, rejected);
|
||||
|
||||
// Refind strategy to detect more markers
|
||||
if(refindStrategy)
|
||||
detector.refineDetectedMarkers(image, board, corners, ids, rejected, camMatrix,
|
||||
distCoeffs);
|
||||
|
||||
//! [aruco_detect_and_refine]
|
||||
|
||||
// Estimate board pose
|
||||
int markersOfBoardDetected = 0;
|
||||
if(!ids.empty()) {
|
||||
// Get object and image points for the solvePnP function
|
||||
cv::Mat objPoints, imgPoints;
|
||||
board.matchImagePoints(corners, ids, objPoints, imgPoints);
|
||||
|
||||
// Find pose
|
||||
cv::solvePnP(objPoints, imgPoints, camMatrix, distCoeffs, rvec, tvec);
|
||||
|
||||
markersOfBoardDetected = (int)objPoints.total() / 4;
|
||||
}
|
||||
|
||||
double currentTime = ((double)getTickCount() - tick) / getTickFrequency();
|
||||
totalTime += currentTime;
|
||||
totalIterations++;
|
||||
if(totalIterations % 30 == 0) {
|
||||
cout << "Detection Time = " << currentTime * 1000 << " ms "
|
||||
<< "(Mean = " << 1000 * totalTime / double(totalIterations) << " ms)" << endl;
|
||||
}
|
||||
|
||||
// Draw results
|
||||
image.copyTo(imageCopy);
|
||||
if(!ids.empty())
|
||||
aruco::drawDetectedMarkers(imageCopy, corners, ids);
|
||||
|
||||
if(showRejected && !rejected.empty())
|
||||
aruco::drawDetectedMarkers(imageCopy, rejected, noArray(), Scalar(100, 0, 255));
|
||||
|
||||
if(markersOfBoardDetected > 0)
|
||||
cv::drawFrameAxes(imageCopy, camMatrix, distCoeffs, rvec, tvec, axisLength);
|
||||
|
||||
imshow("out", imageCopy);
|
||||
char key = (char)waitKey(waitTime);
|
||||
if(key == 27) break;
|
||||
//! [aruco_detect_board_full_sample]
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
//! [charucohdr]
|
||||
#include <opencv2/objdetect/charuco_detector.hpp>
|
||||
//! [charucohdr]
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Pose estimation using a ChArUco board";
|
||||
const char* keys =
|
||||
"{w | | Number of squares in X direction }"
|
||||
"{h | | Number of squares in Y direction }"
|
||||
"{sl | | Square side length (in meters) }"
|
||||
"{ml | | Marker side length (in meters) }"
|
||||
"{d | | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{c | | Output file with calibrated camera parameters }"
|
||||
"{v | | Input from video or image file, if ommited, input comes from camera }"
|
||||
"{ci | 0 | Camera id if input doesnt come from video (-v) }"
|
||||
"{dp | | File of marker detector parameters }"
|
||||
"{rs | | Apply refind strategy }";
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
if(argc < 6) {
|
||||
parser.printMessage();
|
||||
return 0;
|
||||
}
|
||||
|
||||
//! [charuco_detect_board_full_sample]
|
||||
int squaresX = parser.get<int>("w");
|
||||
int squaresY = parser.get<int>("h");
|
||||
float squareLength = parser.get<float>("sl");
|
||||
float markerLength = parser.get<float>("ml");
|
||||
bool refine = parser.has("rs");
|
||||
int camId = parser.get<int>("ci");
|
||||
|
||||
string video;
|
||||
if(parser.has("v")) {
|
||||
video = parser.get<string>("v");
|
||||
}
|
||||
|
||||
Mat camMatrix, distCoeffs;
|
||||
readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
|
||||
aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
VideoCapture inputVideo;
|
||||
int waitTime = 0;
|
||||
if(!video.empty()) {
|
||||
inputVideo.open(video);
|
||||
} else {
|
||||
inputVideo.open(camId);
|
||||
waitTime = 10;
|
||||
}
|
||||
|
||||
float axisLength = 0.5f * ((float)min(squaresX, squaresY) * (squareLength));
|
||||
|
||||
// create charuco board object
|
||||
aruco::CharucoBoard charucoBoard(Size(squaresX, squaresY), squareLength, markerLength, dictionary);
|
||||
|
||||
// create charuco detector
|
||||
aruco::CharucoParameters charucoParams;
|
||||
charucoParams.tryRefineMarkers = refine; // if tryRefineMarkers, refineDetectedMarkers() will be used in detectBoard()
|
||||
charucoParams.cameraMatrix = camMatrix; // cameraMatrix can be used in detectBoard()
|
||||
charucoParams.distCoeffs = distCoeffs; // distCoeffs can be used in detectBoard()
|
||||
aruco::CharucoDetector charucoDetector(charucoBoard, charucoParams, detectorParams);
|
||||
|
||||
double totalTime = 0;
|
||||
int totalIterations = 0;
|
||||
|
||||
while(inputVideo.grab()) {
|
||||
//! [inputImg]
|
||||
Mat image, imageCopy;
|
||||
inputVideo.retrieve(image);
|
||||
//! [inputImg]
|
||||
|
||||
double tick = (double)getTickCount();
|
||||
|
||||
vector<int> markerIds, charucoIds;
|
||||
vector<vector<Point2f> > markerCorners;
|
||||
vector<Point2f> charucoCorners;
|
||||
Vec3d rvec, tvec;
|
||||
|
||||
//! [interpolateCornersCharuco]
|
||||
// detect markers and charuco corners
|
||||
charucoDetector.detectBoard(image, charucoCorners, charucoIds, markerCorners, markerIds);
|
||||
//! [interpolateCornersCharuco]
|
||||
|
||||
//! [poseCharuco]
|
||||
// estimate charuco board pose
|
||||
bool validPose = false;
|
||||
if(camMatrix.total() != 0 && distCoeffs.total() != 0 && charucoIds.size() >= 4) {
|
||||
Mat objPoints, imgPoints;
|
||||
charucoBoard.matchImagePoints(charucoCorners, charucoIds, objPoints, imgPoints);
|
||||
validPose = solvePnP(objPoints, imgPoints, camMatrix, distCoeffs, rvec, tvec);
|
||||
}
|
||||
//! [poseCharuco]
|
||||
|
||||
double currentTime = ((double)getTickCount() - tick) / getTickFrequency();
|
||||
totalTime += currentTime;
|
||||
totalIterations++;
|
||||
if(totalIterations % 30 == 0) {
|
||||
cout << "Detection Time = " << currentTime * 1000 << " ms "
|
||||
<< "(Mean = " << 1000 * totalTime / double(totalIterations) << " ms)" << endl;
|
||||
}
|
||||
|
||||
// draw results
|
||||
image.copyTo(imageCopy);
|
||||
if(markerIds.size() > 0) {
|
||||
aruco::drawDetectedMarkers(imageCopy, markerCorners);
|
||||
}
|
||||
|
||||
if(charucoIds.size() > 0) {
|
||||
//! [drawDetectedCornersCharuco]
|
||||
aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, cv::Scalar(255, 0, 0));
|
||||
//! [drawDetectedCornersCharuco]
|
||||
}
|
||||
|
||||
if(validPose)
|
||||
cv::drawFrameAxes(imageCopy, camMatrix, distCoeffs, rvec, tvec, axisLength);
|
||||
|
||||
imshow("out", imageCopy);
|
||||
if(waitKey(waitTime) == 27) break;
|
||||
}
|
||||
//! [charuco_detect_board_full_sample]
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <opencv2/objdetect/charuco_detector.hpp>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
|
||||
namespace {
|
||||
const char* about = "Detect ChArUco markers";
|
||||
const char* keys =
|
||||
"{sl | 100 | Square side length (in meters) }"
|
||||
"{ml | 60 | Marker side length (in meters) }"
|
||||
"{d | 10 | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL=16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{c | | Output file with calibrated camera parameters }"
|
||||
"{as | | Automatic scale. The provided number is multiplied by the last"
|
||||
"diamond id becoming an indicator of the square length. In this case, the -sl and "
|
||||
"-ml are only used to know the relative length relation between squares and markers }"
|
||||
"{v | | Input from video file, if ommited, input comes from camera }"
|
||||
"{ci | 0 | Camera id if input doesnt come from video (-v) }"
|
||||
"{dp | | File of marker detector parameters }"
|
||||
"{refine | | Corner refinement: CORNER_REFINE_NONE=0, CORNER_REFINE_SUBPIX=1,"
|
||||
"CORNER_REFINE_CONTOUR=2, CORNER_REFINE_APRILTAG=3}";
|
||||
|
||||
const string refineMethods[4] = {
|
||||
"None",
|
||||
"Subpixel",
|
||||
"Contour",
|
||||
"AprilTag"
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
float squareLength = parser.get<float>("sl");
|
||||
float markerLength = parser.get<float>("ml");
|
||||
bool estimatePose = parser.has("c");
|
||||
bool autoScale = parser.has("as");
|
||||
float autoScaleFactor = autoScale ? parser.get<float>("as") : 1.f;
|
||||
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
Mat camMatrix, distCoeffs;
|
||||
readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
|
||||
|
||||
aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
|
||||
if (parser.has("refine")) {
|
||||
// override cornerRefinementMethod read from config file
|
||||
int user_method = parser.get<aruco::CornerRefineMethod>("refine");
|
||||
if (user_method < 0 || user_method >= 4)
|
||||
{
|
||||
std::cout << "Corner refinement method should be in range 0..3" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
detectorParams.cornerRefinementMethod = user_method;
|
||||
}
|
||||
std::cout << "Corner refinement method: " << refineMethods[detectorParams.cornerRefinementMethod] << std::endl;
|
||||
|
||||
int camId = parser.get<int>("ci");
|
||||
String video;
|
||||
|
||||
if(parser.has("v")) {
|
||||
video = parser.get<String>("v");
|
||||
}
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
VideoCapture inputVideo;
|
||||
int waitTime;
|
||||
if(!video.empty()) {
|
||||
inputVideo.open(video);
|
||||
waitTime = 0;
|
||||
} else {
|
||||
inputVideo.open(camId);
|
||||
waitTime = 10;
|
||||
}
|
||||
|
||||
double totalTime = 0;
|
||||
int totalIterations = 0;
|
||||
|
||||
aruco::CharucoBoard charucoBoard(Size(3, 3), squareLength, markerLength, dictionary);
|
||||
aruco::CharucoDetector detector(charucoBoard, aruco::CharucoParameters(), detectorParams);
|
||||
|
||||
while(inputVideo.grab()) {
|
||||
Mat image, imageCopy;
|
||||
inputVideo.retrieve(image);
|
||||
|
||||
double tick = (double)getTickCount();
|
||||
|
||||
//! [detect_diamonds]
|
||||
vector<int> markerIds;
|
||||
vector<Vec4i> diamondIds;
|
||||
vector<vector<Point2f> > markerCorners, diamondCorners;
|
||||
vector<Vec3d> rvecs, tvecs;
|
||||
|
||||
detector.detectDiamonds(image, diamondCorners, diamondIds, markerCorners, markerIds);
|
||||
//! [detect_diamonds]
|
||||
|
||||
//! [diamond_pose_estimation]
|
||||
// estimate diamond pose
|
||||
size_t N = diamondIds.size();
|
||||
if(estimatePose && N > 0) {
|
||||
cv::Mat objPoints(4, 1, CV_32FC3);
|
||||
rvecs.resize(N);
|
||||
tvecs.resize(N);
|
||||
if(!autoScale) {
|
||||
// set coordinate system
|
||||
objPoints.ptr<Vec3f>(0)[0] = Vec3f(-squareLength/2.f, squareLength/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[1] = Vec3f(squareLength/2.f, squareLength/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[2] = Vec3f(squareLength/2.f, -squareLength/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[3] = Vec3f(-squareLength/2.f, -squareLength/2.f, 0);
|
||||
// Calculate pose for each marker
|
||||
for (size_t i = 0ull; i < N; i++)
|
||||
solvePnP(objPoints, diamondCorners.at(i), camMatrix, distCoeffs, rvecs.at(i), tvecs.at(i));
|
||||
//! [diamond_pose_estimation]
|
||||
/* //! [diamond_pose_estimation_as_charuco]
|
||||
for (size_t i = 0ull; i < N; i++) { // estimate diamond pose as Charuco board
|
||||
Mat objPoints_b, imgPoints;
|
||||
// The coordinate system of the diamond is placed in the board plane centered in the bottom left corner
|
||||
vector<int> charucoIds = {0, 1, 3, 2}; // if CCW order, Z axis pointing in the plane
|
||||
// vector<int> charucoIds = {0, 2, 3, 1}; // if CW order, Z axis pointing out the plane
|
||||
charucoBoard.matchImagePoints(diamondCorners[i], charucoIds, objPoints_b, imgPoints);
|
||||
solvePnP(objPoints_b, imgPoints, camMatrix, distCoeffs, rvecs[i], tvecs[i]);
|
||||
}
|
||||
//! [diamond_pose_estimation_as_charuco] */
|
||||
}
|
||||
else {
|
||||
// if autoscale, extract square size from last diamond id
|
||||
for(size_t i = 0; i < N; i++) {
|
||||
float sqLenScale = autoScaleFactor * float(diamondIds[i].val[3]);
|
||||
vector<vector<Point2f> > currentCorners;
|
||||
vector<Vec3d> currentRvec, currentTvec;
|
||||
currentCorners.push_back(diamondCorners[i]);
|
||||
// set coordinate system
|
||||
objPoints.ptr<Vec3f>(0)[0] = Vec3f(-sqLenScale/2.f, sqLenScale/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[1] = Vec3f(sqLenScale/2.f, sqLenScale/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[2] = Vec3f(sqLenScale/2.f, -sqLenScale/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[3] = Vec3f(-sqLenScale/2.f, -sqLenScale/2.f, 0);
|
||||
solvePnP(objPoints, diamondCorners.at(i), camMatrix, distCoeffs, rvecs.at(i), tvecs.at(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
double currentTime = ((double)getTickCount() - tick) / getTickFrequency();
|
||||
totalTime += currentTime;
|
||||
totalIterations++;
|
||||
if(totalIterations % 30 == 0) {
|
||||
cout << "Detection Time = " << currentTime * 1000 << " ms "
|
||||
<< "(Mean = " << 1000 * totalTime / double(totalIterations) << " ms)" << endl;
|
||||
}
|
||||
|
||||
|
||||
// draw results
|
||||
image.copyTo(imageCopy);
|
||||
if(markerIds.size() > 0)
|
||||
aruco::drawDetectedMarkers(imageCopy, markerCorners);
|
||||
|
||||
//! [draw_diamonds]
|
||||
if(diamondIds.size() > 0) {
|
||||
aruco::drawDetectedDiamonds(imageCopy, diamondCorners, diamondIds);
|
||||
//! [draw_diamonds]
|
||||
|
||||
//! [draw_diamond_pose_estimation]
|
||||
if(estimatePose) {
|
||||
for(size_t i = 0u; i < diamondIds.size(); i++)
|
||||
cv::drawFrameAxes(imageCopy, camMatrix, distCoeffs, rvecs[i], tvecs[i], squareLength*1.1f);
|
||||
}
|
||||
//! [draw_diamond_pose_estimation]
|
||||
}
|
||||
imshow("out", imageCopy);
|
||||
char key = (char)waitKey(waitTime);
|
||||
if(key == 27) break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
#include <opencv2/highgui.hpp>
|
||||
#include <opencv2/objdetect/aruco_detector.hpp>
|
||||
#include <iostream>
|
||||
#include "aruco_samples_utility.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
namespace {
|
||||
const char* about = "Basic marker detection";
|
||||
|
||||
//! [aruco_detect_markers_keys]
|
||||
const char* keys =
|
||||
"{d | 0 | dictionary: DICT_4X4_50=0, DICT_4X4_100=1, DICT_4X4_250=2,"
|
||||
"DICT_4X4_1000=3, DICT_5X5_50=4, DICT_5X5_100=5, DICT_5X5_250=6, DICT_5X5_1000=7, "
|
||||
"DICT_6X6_50=8, DICT_6X6_100=9, DICT_6X6_250=10, DICT_6X6_1000=11, DICT_7X7_50=12,"
|
||||
"DICT_7X7_100=13, DICT_7X7_250=14, DICT_7X7_1000=15, DICT_ARUCO_ORIGINAL = 16,"
|
||||
"DICT_APRILTAG_16h5=17, DICT_APRILTAG_25h9=18, DICT_APRILTAG_36h10=19, DICT_APRILTAG_36h11=20, DICT_ARUCO_MIP_36h12=21}"
|
||||
"{cd | | Input file with custom dictionary }"
|
||||
"{v | | Input from video or image file, if ommited, input comes from camera }"
|
||||
"{ci | 0 | Camera id if input doesnt come from video (-v) }"
|
||||
"{c | | Camera intrinsic parameters. Needed for camera pose }"
|
||||
"{l | 0.1 | Marker side length (in meters). Needed for correct scale in camera pose }"
|
||||
"{dp | | File of marker detector parameters }"
|
||||
"{r | | show rejected candidates too }"
|
||||
"{refine | | Corner refinement: CORNER_REFINE_NONE=0, CORNER_REFINE_SUBPIX=1,"
|
||||
"CORNER_REFINE_CONTOUR=2, CORNER_REFINE_APRILTAG=3}";
|
||||
|
||||
//! [aruco_detect_markers_keys]
|
||||
|
||||
const string refineMethods[4] = {
|
||||
"None",
|
||||
"Subpixel",
|
||||
"Contour",
|
||||
"AprilTag"
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
CommandLineParser parser(argc, argv, keys);
|
||||
parser.about(about);
|
||||
|
||||
bool showRejected = parser.has("r");
|
||||
bool estimatePose = parser.has("c");
|
||||
float markerLength = parser.get<float>("l");
|
||||
|
||||
aruco::DetectorParameters detectorParams = readDetectorParamsFromCommandLine(parser);
|
||||
aruco::Dictionary dictionary = readDictionatyFromCommandLine(parser);
|
||||
|
||||
if (parser.has("refine")) {
|
||||
// override cornerRefinementMethod read from config file
|
||||
int user_method = parser.get<aruco::CornerRefineMethod>("refine");
|
||||
if (user_method < 0 || user_method >= 4)
|
||||
{
|
||||
std::cout << "Corner refinement method should be in range 0..3" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
detectorParams.cornerRefinementMethod = user_method;
|
||||
}
|
||||
|
||||
std::cout << "Corner refinement method: " << refineMethods[detectorParams.cornerRefinementMethod] << std::endl;
|
||||
|
||||
int camId = parser.get<int>("ci");
|
||||
|
||||
String video;
|
||||
if(parser.has("v")) {
|
||||
video = parser.get<String>("v");
|
||||
}
|
||||
|
||||
if(!parser.check()) {
|
||||
parser.printErrors();
|
||||
return 0;
|
||||
}
|
||||
|
||||
//! [aruco_pose_estimation1]
|
||||
Mat camMatrix, distCoeffs;
|
||||
if(estimatePose) {
|
||||
// You can read camera parameters from tutorial_camera_params.yml
|
||||
readCameraParamsFromCommandLine(parser, camMatrix, distCoeffs);
|
||||
}
|
||||
//! [aruco_pose_estimation1]
|
||||
//! [aruco_detect_markers]
|
||||
cv::aruco::ArucoDetector detector(dictionary, detectorParams);
|
||||
cv::VideoCapture inputVideo;
|
||||
int waitTime;
|
||||
if(!video.empty()) {
|
||||
inputVideo.open(video);
|
||||
waitTime = 0;
|
||||
} else {
|
||||
inputVideo.open(camId);
|
||||
waitTime = 10;
|
||||
}
|
||||
|
||||
double totalTime = 0;
|
||||
int totalIterations = 0;
|
||||
|
||||
//! [aruco_pose_estimation2]
|
||||
// set coordinate system
|
||||
cv::Mat objPoints(4, 1, CV_32FC3);
|
||||
objPoints.ptr<Vec3f>(0)[0] = Vec3f(-markerLength/2.f, markerLength/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[1] = Vec3f(markerLength/2.f, markerLength/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[2] = Vec3f(markerLength/2.f, -markerLength/2.f, 0);
|
||||
objPoints.ptr<Vec3f>(0)[3] = Vec3f(-markerLength/2.f, -markerLength/2.f, 0);
|
||||
//! [aruco_pose_estimation2]
|
||||
|
||||
while(inputVideo.grab()) {
|
||||
cv::Mat image, imageCopy;
|
||||
inputVideo.retrieve(image);
|
||||
|
||||
double tick = (double)getTickCount();
|
||||
|
||||
//! [aruco_pose_estimation3]
|
||||
vector<int> ids;
|
||||
vector<vector<Point2f> > corners, rejected;
|
||||
|
||||
// detect markers and estimate pose
|
||||
detector.detectMarkers(image, corners, ids, rejected);
|
||||
|
||||
size_t nMarkers = corners.size();
|
||||
vector<Vec3d> rvecs(nMarkers), tvecs(nMarkers);
|
||||
|
||||
if(estimatePose && !ids.empty()) {
|
||||
// Calculate pose for each marker
|
||||
for (size_t i = 0; i < nMarkers; i++) {
|
||||
solvePnP(objPoints, corners.at(i), camMatrix, distCoeffs, rvecs.at(i), tvecs.at(i));
|
||||
}
|
||||
}
|
||||
//! [aruco_pose_estimation3]
|
||||
double currentTime = ((double)getTickCount() - tick) / getTickFrequency();
|
||||
totalTime += currentTime;
|
||||
totalIterations++;
|
||||
if(totalIterations % 30 == 0) {
|
||||
cout << "Detection Time = " << currentTime * 1000 << " ms "
|
||||
<< "(Mean = " << 1000 * totalTime / double(totalIterations) << " ms)" << endl;
|
||||
}
|
||||
//! [aruco_draw_pose_estimation]
|
||||
// draw results
|
||||
image.copyTo(imageCopy);
|
||||
if(!ids.empty()) {
|
||||
cv::aruco::drawDetectedMarkers(imageCopy, corners, ids);
|
||||
|
||||
if(estimatePose) {
|
||||
for(unsigned int i = 0; i < ids.size(); i++)
|
||||
cv::drawFrameAxes(imageCopy, camMatrix, distCoeffs, rvecs[i], tvecs[i], markerLength * 1.5f, 2);
|
||||
}
|
||||
}
|
||||
//! [aruco_draw_pose_estimation]
|
||||
|
||||
if(showRejected && !rejected.empty())
|
||||
cv::aruco::drawDetectedMarkers(imageCopy, rejected, noArray(), Scalar(100, 0, 255));
|
||||
|
||||
imshow("out", imageCopy);
|
||||
char key = (char)waitKey(waitTime);
|
||||
if(key == 27) break;
|
||||
}
|
||||
//! [aruco_detect_markers]
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
%YAML:1.0
|
||||
adaptiveThreshWinSizeMin: 3
|
||||
adaptiveThreshWinSizeMax: 23
|
||||
adaptiveThreshWinSizeStep: 10
|
||||
adaptiveThreshWinSize: 21
|
||||
adaptiveThreshConstant: 7
|
||||
minMarkerPerimeterRate: 0.03
|
||||
maxMarkerPerimeterRate: 4.0
|
||||
polygonalApproxAccuracyRate: 0.05
|
||||
minCornerDistanceRate: 0.05
|
||||
minDistanceToBorder: 3
|
||||
minMarkerDistance: 10.0
|
||||
minMarkerDistanceRate: 0.05
|
||||
cornerRefinementMethod: 0
|
||||
cornerRefinementWinSize: 5
|
||||
cornerRefinementMaxIterations: 30
|
||||
cornerRefinementMinAccuracy: 0.1
|
||||
markerBorderBits: 1
|
||||
perspectiveRemovePixelPerCell: 8
|
||||
perspectiveRemoveIgnoredMarginPerCell: 0.13
|
||||
maxErroneousBitsInBorderRate: 0.04
|
||||
minOtsuStdDev: 5.0
|
||||
errorCorrectionRate: 0.6
|
||||
|
||||
# new aruco 3 functionality
|
||||
useAruco3Detection: 0
|
||||
minSideLengthCanonicalImg: 32 # 16, 32, 64 --> tau_c from the paper
|
||||
minMarkerLengthRatioOriginalImg: 0.02 # range [0,0.2] --> tau_i from the paper
|
||||
cameraMotionSpeed: 0.1 # range [0,1) --> tau_s from the paper
|
||||
useGlobalThreshold: 0
|
||||
@@ -0,0 +1,107 @@
|
||||
#include "opencv2/objdetect.hpp"
|
||||
#include "opencv2/highgui.hpp"
|
||||
#include "opencv2/imgproc.hpp"
|
||||
#include "opencv2/videoio.hpp"
|
||||
#include <iostream>
|
||||
|
||||
using namespace std;
|
||||
using namespace cv;
|
||||
|
||||
/** Function Headers */
|
||||
void detectAndDisplay( Mat frame );
|
||||
|
||||
/** Global variables */
|
||||
CascadeClassifier face_cascade;
|
||||
CascadeClassifier eyes_cascade;
|
||||
|
||||
/** @function main */
|
||||
int main( int argc, const char** argv )
|
||||
{
|
||||
CommandLineParser parser(argc, argv,
|
||||
"{help h||}"
|
||||
"{face_cascade|data/haarcascades/haarcascade_frontalface_alt.xml|Path to face cascade.}"
|
||||
"{eyes_cascade|data/haarcascades/haarcascade_eye_tree_eyeglasses.xml|Path to eyes cascade.}"
|
||||
"{camera|0|Camera device number.}");
|
||||
|
||||
parser.about( "\nThis program demonstrates using the cv::CascadeClassifier class to detect objects (Face + eyes) in a video stream.\n"
|
||||
"You can use Haar or LBP features.\n\n" );
|
||||
parser.printMessage();
|
||||
|
||||
String face_cascade_name = samples::findFile( parser.get<String>("face_cascade") );
|
||||
String eyes_cascade_name = samples::findFile( parser.get<String>("eyes_cascade") );
|
||||
|
||||
//-- 1. Load the cascades
|
||||
if( !face_cascade.load( face_cascade_name ) )
|
||||
{
|
||||
cout << "--(!)Error loading face cascade\n";
|
||||
return -1;
|
||||
};
|
||||
if( !eyes_cascade.load( eyes_cascade_name ) )
|
||||
{
|
||||
cout << "--(!)Error loading eyes cascade\n";
|
||||
return -1;
|
||||
};
|
||||
|
||||
int camera_device = parser.get<int>("camera");
|
||||
VideoCapture capture;
|
||||
//-- 2. Read the video stream
|
||||
capture.open( camera_device );
|
||||
if ( ! capture.isOpened() )
|
||||
{
|
||||
cout << "--(!)Error opening video capture\n";
|
||||
return -1;
|
||||
}
|
||||
|
||||
Mat frame;
|
||||
while ( capture.read(frame) )
|
||||
{
|
||||
if( frame.empty() )
|
||||
{
|
||||
cout << "--(!) No captured frame -- Break!\n";
|
||||
break;
|
||||
}
|
||||
|
||||
//-- 3. Apply the classifier to the frame
|
||||
detectAndDisplay( frame );
|
||||
|
||||
if( waitKey(10) == 27 )
|
||||
{
|
||||
break; // escape
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** @function detectAndDisplay */
|
||||
void detectAndDisplay( Mat frame )
|
||||
{
|
||||
Mat frame_gray;
|
||||
cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
|
||||
equalizeHist( frame_gray, frame_gray );
|
||||
|
||||
//-- Detect faces
|
||||
std::vector<Rect> faces;
|
||||
face_cascade.detectMultiScale( frame_gray, faces );
|
||||
|
||||
for ( size_t i = 0; i < faces.size(); i++ )
|
||||
{
|
||||
Point center( faces[i].x + faces[i].width/2, faces[i].y + faces[i].height/2 );
|
||||
ellipse( frame, center, Size( faces[i].width/2, faces[i].height/2 ), 0, 0, 360, Scalar( 255, 0, 255 ), 4 );
|
||||
|
||||
Mat faceROI = frame_gray( faces[i] );
|
||||
|
||||
//-- In each face, detect eyes
|
||||
std::vector<Rect> eyes;
|
||||
eyes_cascade.detectMultiScale( faceROI, eyes );
|
||||
|
||||
for ( size_t j = 0; j < eyes.size(); j++ )
|
||||
{
|
||||
Point eye_center( faces[i].x + eyes[j].x + eyes[j].width/2, faces[i].y + eyes[j].y + eyes[j].height/2 );
|
||||
int radius = cvRound( (eyes[j].width + eyes[j].height)*0.25 );
|
||||
circle( frame, eye_center, radius, Scalar( 255, 0, 0 ), 4 );
|
||||
}
|
||||
}
|
||||
|
||||
//-- Show what you got
|
||||
imshow( "Capture - Face detection", frame );
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
%YAML:1.0
|
||||
---
|
||||
calibration_time: "Wed 08 Dec 2021 05:13:09 PM MSK"
|
||||
image_width: 640
|
||||
image_height: 480
|
||||
flags: 0
|
||||
camera_matrix: !!opencv-matrix
|
||||
rows: 3
|
||||
cols: 3
|
||||
dt: d
|
||||
data: [ 4.5251072219637672e+02, 0., 3.1770297317353277e+02, 0.,
|
||||
4.5676707935146891e+02, 2.7775155919135995e+02, 0., 0., 1. ]
|
||||
distortion_coefficients: !!opencv-matrix
|
||||
rows: 1
|
||||
cols: 5
|
||||
dt: d
|
||||
data: [ 1.2136925618707872e-01, -1.0854664722560681e+00,
|
||||
1.1786843796668460e-04, -4.6240686046485508e-04,
|
||||
2.9542589406810080e+00 ]
|
||||
avg_reprojection_error: 1.8234905535936044e-01
|
||||
info: "The camera calibration parameters were obtained by img_00.jpg-img_03.jpg from aruco/tutorials/aruco_calibration/images"
|
||||
@@ -0,0 +1,14 @@
|
||||
%YAML:1.0
|
||||
camera_matrix: !!opencv-matrix
|
||||
rows: 3
|
||||
cols: 3
|
||||
dt: d
|
||||
data: [ 628.158, 0., 324.099,
|
||||
0., 628.156, 260.908,
|
||||
0., 0., 1. ]
|
||||
distortion_coefficients: !!opencv-matrix
|
||||
rows: 5
|
||||
cols: 1
|
||||
dt: d
|
||||
data: [ 0.0995485, -0.206384,
|
||||
0.00754589, 0.00336531, 0 ]
|
||||
@@ -0,0 +1,38 @@
|
||||
%YAML:1.0
|
||||
nmarkers: 35
|
||||
markersize: 6
|
||||
marker_0: "101011111011111001001001101100000000"
|
||||
marker_1: "000000000010011001010011111010111000"
|
||||
marker_2: "011001100000001010000101111101001101"
|
||||
marker_3: "001000111111000111011001110000011111"
|
||||
marker_4: "100110110100101111000000111101110011"
|
||||
marker_5: "010101101110111000111010111100010111"
|
||||
marker_6: "101001000110011110101001010100110100"
|
||||
marker_7: "011010100100110000011101110110100010"
|
||||
marker_8: "111110001000101000110001010010111101"
|
||||
marker_9: "011101101100110111001100100001010100"
|
||||
marker_10: "100001100001010001110001011000000111"
|
||||
marker_11: "110010010010011100101111111000001111"
|
||||
marker_12: "110101001001010110011111010110001101"
|
||||
marker_13: "001111000001000100010001101001010001"
|
||||
marker_14: "000000010010101010111110110011010011"
|
||||
marker_15: "110001110111100101110011111100111010"
|
||||
marker_16: "101011001110001010110011111011001110"
|
||||
marker_17: "101110111101110100101101011001010111"
|
||||
marker_18: "000100111000111101010011010101000101"
|
||||
marker_19: "001110001110001101100101110100000011"
|
||||
marker_20: "100101101100010110110110110001100011"
|
||||
marker_21: "010110001001011010000100111000110110"
|
||||
marker_22: "001000000000100100000000010100010010"
|
||||
marker_23: "101001110010100110000111111010010000"
|
||||
marker_24: "111001101010001100011010010001011100"
|
||||
marker_25: "101000010001010000110100111101101001"
|
||||
marker_26: "101010000001010011001010110110000001"
|
||||
marker_27: "100101001000010101001000111101111110"
|
||||
marker_28: "010010100110010011110001110101011100"
|
||||
marker_29: "011001000101100001101111010001001111"
|
||||
marker_30: "000111011100011110001101111011011001"
|
||||
marker_31: "010100001011000100111101110001101010"
|
||||
marker_32: "100101101001101010111111101101110100"
|
||||
marker_33: "101101001010111000000100110111010101"
|
||||
marker_34: "011111010000111011111110110101100101"
|
||||
Reference in New Issue
Block a user