/////////////////////////////////////////////////////// // Panel::CalibrateCamera() Description /////////////////////////////////////////////////////// void Panel::CalibrateCamera(string sFilePath) { help(); //! [file_read] Settings s; const string inputSettingsFile = sFilePath; FileStorage fs(inputSettingsFile, FileStorage::READ); // Read the settings if (!fs.isOpened()) { cout << "Could not open the configuration file: \"" << inputSettingsFile << "\"" << endl; // return -1; } fs["Settings"] >> s; fs.release(); // close Settings file //! [file_read] //FileStorage fout("settings.yml", FileStorage::WRITE); // write config as YAML //fout << "Settings" << s; if (!s.goodInput) { cout << "Invalid input detected. Application stopping. " << endl; // return -1; } vector<vector<Point2f> > imagePoints; Mat cameraMatrix, distCoeffs; Size imageSize; int mode = s.inputType == Settings::IMAGE_LIST ? CAPTURING : DETECTION; clock_t prevTimestamp = 0; const Scalar RED(0, 0, 255), GREEN(0, 255, 0); const char ESC_KEY = 27; int counter = 1; //! [get_input] for (;;) { Mat view; bool blinkOutput = false; view = s.nextImage(); //----- If no more image, or got enough, then stop calibration and show result ------------- if (mode == CAPTURING && imagePoints.size() >= (size_t)s.nrFrames) { if (runCalibrationAndSave(s, imageSize, cameraMatrix, distCoeffs, imagePoints)) mode = CALIBRATED; else mode = DETECTION; } if (view.empty()) // If there are no more images stop the loop { // if calibration threshold was not reached yet, calibrate now if (mode != CALIBRATED && !imagePoints.empty()) runCalibrationAndSave(s, imageSize, cameraMatrix, distCoeffs, imagePoints); break; } //! [get_input] imageSize = view.size(); // Format input image. if (s.flipVertical) flip(view, view, 0); //! [find_pattern] vector<Point2f> pointBuf; bool found; switch (s.calibrationPattern) // Find feature points on the input format { case Settings::CHESSBOARD: found = findChessboardCorners(view, s.boardSize, pointBuf, CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_FAST_CHECK | CALIB_CB_NORMALIZE_IMAGE); break; case Settings::CIRCLES_GRID: found = findCirclesGrid(view, s.boardSize, pointBuf); break; case Settings::ASYMMETRIC_CIRCLES_GRID: found = findCirclesGrid(view, s.boardSize, pointBuf, CALIB_CB_ASYMMETRIC_GRID); break; default: found = false; break; } //! [find_pattern] //! [pattern_found] if (found) // If done with success, { // improve the found corners' coordinate accuracy for chessboard if (s.calibrationPattern == Settings::CHESSBOARD) { Mat viewGray; cvtColor(view, viewGray, COLOR_BGR2GRAY); cornerSubPix(viewGray, pointBuf, Size(11, 11), Size(-1, -1), TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 30, 0.1)); } if (mode == CAPTURING && // For camera only take new samples after delay time (!s.inputCapture.isOpened() || clock() - prevTimestamp > s.delay*1e-3*CLOCKS_PER_SEC)) { imagePoints.push_back(pointBuf); prevTimestamp = clock(); blinkOutput = s.inputCapture.isOpened(); } // Draw the corners. drawChessboardCorners(view, s.boardSize, Mat(pointBuf), found); } //! [pattern_found] //----------------------------- Output Text ------------------------------------------------ //! [output_text] string msg = (mode == CAPTURING) ? "100/100" : mode == CALIBRATED ? "Calibrated" : "Press 'g' to start"; int baseLine = 0; Size textSize = getTextSize(msg, 1, 1, 1, &baseLine); Point textOrigin(view.cols - 2 * textSize.width - 10, view.rows - 2 * baseLine - 10); if (mode == CAPTURING) { if (s.showUndistorsed) msg = format("%d/%d Undist", (int)imagePoints.size(), s.nrFrames); else msg = format("%d/%d", (int)imagePoints.size(), s.nrFrames); } putText(view, msg, textOrigin, 1, 1, mode == CALIBRATED ? GREEN : RED); if (blinkOutput) bitwise_not(view, view); //! [output_text] //------------------------- Video capture output undistorted ------------------------------ //! [output_undistorted] if (mode == CALIBRATED && s.showUndistorsed) { Mat temp = view.clone(); undistort(temp, view, cameraMatrix, distCoeffs); } //! [output_undistorted] //------------------------------ Show image and check for input commands ------------------- //! [await_input] namedWindow("Image View" + to_string(counter), WINDOW_NORMAL); resizeWindow("Image View" + to_string(counter), 640, 480); imshow("Image View" + to_string(counter), view); char key = (char)waitKey(s.inputCapture.isOpened() ? 50 : s.delay); cout << "Image " << to_string(counter) << " Completed" << endl; counter++; if (key == ESC_KEY) break; if (key == 'u' && mode == CALIBRATED) s.showUndistorsed = !s.showUndistorsed; if (s.inputCapture.isOpened() && key == 'g') { mode = CAPTURING; imagePoints.clear(); } //! [await_input] } // -----------------------Show the undistorted image for the image list ------------------------ //! [show_results] if (s.inputType == Settings::IMAGE_LIST && s.showUndistorsed) { Mat view, rview, map1, map2; initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(), getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0), imageSize, CV_16SC2, map1, map2); m_mainMap1 = map1; m_mainMap2 = map2; for (size_t i = 0; i < s.imageList.size(); i++) { view = imread(s.imageList[i], 1); if (view.empty()) continue; remap(view, rview, map1, map2, INTER_LINEAR); imshow("Image View", rview); char c = (char)waitKey(); if (c == ESC_KEY || c == 'q' || c == 'Q') break; } } //! [show_results] // return 0; }
/////////////////////////////////////////////////////////////////// // Panel::MaskWithColor() // Description: /////////////////////////////////////////////////////////////////// void Panel::MaskWithColor(string sImgPath, string color, bool debug) { Mat HSV, Mask, Mask1, Mask2, MaskResult; // Show the original image if(!ShowImage(sImgPath, "Original")) return; Mat image; if (m_roi.width && m_roi.width <= m_Image.cols && m_roi.height && m_roi.height <= m_Image.rows) image = m_pPanel->m_Image(m_roi); else image = m_pPanel->m_Image; // Convert the color HSV Format cvtColor(image, HSV, CV_BGR2HSV); // The inRange() function will create a mask with // only the pixels of color in the range specified if (color == "Blue") { inRange(HSV, Scalar(105, 100, 30), Scalar(131, 255, 255), Mask); } else if (color == "Red") { inRange(HSV, Scalar(0, 100, 30), Scalar(6, 255, 255), Mask1); inRange(HSV, Scalar(165, 100, 30), Scalar(179, 255, 255), Mask2); bitwise_or(Mask1, Mask2, Mask); } else if (color == "panel") { // test code int h1Lo = 0, s1Lo = 55, v1Lo = 115; int h1Hi = 20, s1Hi = 120, v1Hi = 210; int h2Lo = 0, s2Lo = 0, v2Lo = 0; int h2Hi = 0, s2Hi = 0, v2Hi = 0; namedWindow("InRange Tester", CV_WINDOW_NORMAL); cvCreateTrackbar("Hue Lo 1:", "InRange Tester", &h1Lo, 180); cvCreateTrackbar("Hue Hi 1:", "InRange Tester", &h1Hi, 180); cvCreateTrackbar("Sat Lo 1", "InRange Tester", &s1Lo, 255); cvCreateTrackbar("Sat Hi 1", "InRange Tester", &s1Hi, 255); cvCreateTrackbar("Val Lo 1", "InRange Tester", &v1Lo, 255); cvCreateTrackbar("Val Hi 1", "InRange Tester", &v1Hi, 255); cvCreateTrackbar("Hue Lo 2:", "InRange Tester", &h2Lo, 180); cvCreateTrackbar("Hue Hi 2:", "InRange Tester", &h2Hi, 180); cvCreateTrackbar("Sat Lo 2", "InRange Tester", &s2Lo, 255); cvCreateTrackbar("Sat Hi 2", "InRange Tester", &s2Hi, 255); cvCreateTrackbar("Val Lo 2", "InRange Tester", &v2Lo, 255); cvCreateTrackbar("Val Hi 2", "InRange Tester", &v2Hi, 255); while (true) { inRange(HSV, Scalar(h1Lo, s1Lo, v1Lo), Scalar(h1Hi, s1Hi, v1Hi), Mask1); inRange(HSV, Scalar(h2Lo, s2Lo, v2Lo), Scalar(h2Hi, s2Hi, v2Hi), Mask2); bitwise_or(Mask1, Mask2, Mask); image.copyTo(MaskResult, Mask); namedWindow("Mask Result", CV_WINDOW_NORMAL); imshow("Mask Result", MaskResult); if (waitKey(50) == 27) break; } } image.copyTo(MaskResult, Mask); if (color == "Red" || color == "Blue") { // Use the below lines to debug red or blue color mask // namedWindow("Mask Result", CV_WINDOW_AUTOSIZE); // imshow("Mask Result", MaskResult); DetectBlob(MaskResult, debug); } }
void GazeTracker::draw(Mat& image) { Mat faceEyesInfo; Mat focus; double t = (double)cvGetTickCount();//用来计算算法执行时间 detector.detectFaceAndEyes(image, 1); t = (double)cvGetTickCount() - t;//相减为算法执行的时间 printf( "detection time = %g ms\n", t/((double)cvGetTickFrequency()*1000.) ); if(detector.isRecorded || detector.isFaceDetected) { faceEyesInfo = detector.getFaceAndEyePos(); } else { faceEyesInfo.data = NULL; } if(isClicked == true) { float s[1][2]; s[0][0] = click.x; s[0][1] = click.y; Mat output(1, 2, CV_32FC1, s); if(faceEyesInfo.data == NULL) { cout << "fail to detect eyes!" << endl; } else { // focusFinder.train(faceEyesInfo, SampleTypes::ROW_SAMPLE, output); // cout << "eyes detected and trained!" << endl; // focusFinder.save(MODULEPATH); //写入记录 recorder << detector.faceCenter.x << ' ' << detector.faceCenter.y << ' ' << detector.faceSize.x << ' ' << detector.leftEyeCenter.x << ' ' << detector.leftEyeCenter.y << ' ' << detector.leftEyeSize.x << ' ' << detector.rightEyeCenter.x << ' ' << detector.rightEyeCenter.y << ' ' << detector.rightEyeSize.x << ' ' << s[0][0] << ' ' << s[0][1] << endl; cout << detector.faceCenter.x << ' ' << detector.faceCenter.y << ' ' << detector.faceSize.x << ' ' << detector.leftEyeCenter.x << ' ' << detector.leftEyeCenter.y << ' ' << detector.leftEyeSize.x << ' ' << detector.rightEyeCenter.x << ' ' << detector.rightEyeCenter.y << ' ' << detector.rightEyeSize.x << ' ' << s[0][0] << ' ' << s[0][1] << endl; } } isClicked = false; if(detector.isRecorded) { int faceRadius, leftEyeRadius, rightEyeRadius; faceRadius = 1; circle(image, Point(detector.faceCenter.x, detector.faceCenter.y), faceRadius, CV_RGB(0,0,255), 3, 8, 0); leftEyeRadius = (detector.leftEyeSize.x + detector.leftEyeSize.y) / 3; leftEyeRadius = 1; circle(image, Point(detector.leftEyeCenter.x, detector.leftEyeCenter.y), leftEyeRadius, CV_RGB(0,0,255), 3, 8, 0); rightEyeRadius = (detector.rightEyeSize.x + detector.rightEyeSize.y) / 3; rightEyeRadius = 1; circle(image, Point(detector.rightEyeCenter.x, detector.rightEyeCenter.y), rightEyeRadius, CV_RGB(0,0,255), 3, 8, 0); } else if(detector.isFaceDetected) { int faceRadius = (detector.faceSize.x + detector.faceSize.y) / 3; circle(image, Point(detector.faceCenter.x, detector.faceCenter.y), faceRadius, CV_RGB(0,0,255), 3, 8, 0); } Mat bigImg(800, 1100, CV_8UC3); resize(image, bigImg, bigImg.size()); imshow(windowName, bigImg); waitKey(1); }
void PoseEstimator::compute(vector<Point>& points_in) { points_current = points_in; // compute_optimized(); string pose_name_dist_min = ""; float dist_min = 9999; int index = -1; for (vector<Point>& points : points_collection) { ++index; Mat cost_mat = compute_cost_mat(points_current, points, false); float dist = compute_dtw(cost_mat); if (dist < dist_min) { dist_min = dist; PoseEstimator::points_dist_min = points; pose_name_dist_min = names_collection[index]; if (labels_collection.size() > index) PoseEstimator::labels_dist_min = labels_collection[index]; } } bool boolean0 = record_pose; bool boolean1 = target_pose_name != ""; bool boolean2 = points_current.size() > 500; if ((boolean0 && boolean1 && boolean2) || force_record_pose) { force_record_pose = false; save(target_pose_name); cout << pose_name_dist_min << "->" << target_pose_name << " " << to_string(dist_min) << endl; } if (dist_min != 9999) { Mat image_dist_min = Mat::zeros(HEIGHT_SMALL, WIDTH_SMALL, CV_8UC3); static vector<Scalar> colors; if (colors.size() == 0) { colors.push_back(Scalar(255, 0, 0)); colors.push_back(Scalar(0, 153, 0)); colors.push_back(Scalar(0, 0, 255)); colors.push_back(Scalar(153, 0, 102)); colors.push_back(Scalar(102, 102, 102)); } int label_indexes[1000]; int label_indexes_count = 0; { int label_index = -1; for (Point& pt : PoseEstimator::labels_dist_min) { ++label_index; for (int i = pt.x; i <= pt.y; ++i) { label_indexes[i] = label_index; ++label_indexes_count; } } } { int index = -1; Point pt_old = Point(-1, -1); for (Point& pt : PoseEstimator::points_dist_min) { ++index; if (index >= label_indexes_count) continue; int label_index = label_indexes[index]; if (pt_old.x != -1) line(image_dist_min, pt, pt_old, colors[label_index], 1); pt_old = pt; } } if (show) imshow("image_dist_min", image_dist_min); } string pose_name_temp; accumulate_pose(pose_name_dist_min, 10, pose_name_temp); if (pose_name_temp != "") pose_name = pose_name_temp; if (show) cout << pose_name_temp << endl; Mat image_current = Mat::zeros(HEIGHT_SMALL, WIDTH_SMALL, CV_8UC1); Point pt_old = Point(-1, -1); for (Point& pt : points_current) { if (pt_old.x != -1) line(image_current, pt, pt_old, Scalar(254), 1); pt_old = pt; } if (show) { imshow("image_current", image_current); waitKey(1); } }
void compute_optimized() { const int divisions = 5; const int generations = 10; const int initial_seed_num = 10; const int min_seed_num = 1; const int max_seed_num = 10; const int items_in_each_division = points_collection.size() / divisions; const int points_collection_size = points_collection.size(); int total_iterations = 0; bool checker[1000] { 0 }; unordered_map<int, float> division_dist_min_checker; unordered_map<float, int> dist_min_division_checker; unordered_map<float, bool> dist_min_checker; unordered_map<float, int> dist_min_index_checker; float dist_min_selected = 9999; vector<Point> database_points_selected; for (int i = 0; i < generations; ++i) { for (int a = 0; a < (points_collection_size - 1); a += items_in_each_division) { int index_min = a; int index_max = a + items_in_each_division; vector<int> seed_indexes; for (int b = index_min; b <= index_max; ++b) seed_indexes.push_back(b); if (seed_indexes.size() == 0) continue; int seed_num = initial_seed_num; if (i > 0) { float dist_min = division_dist_min_checker[a]; int index_division = dist_min_index_checker[dist_min]; seed_num = map_val(index_division, 0, divisions - 1, min_seed_num, max_seed_num); } for (int b = 0; b < seed_num; ++b) { int k = get_random(0, seed_indexes.size() - 1); int seed_index = seed_indexes[k]; if (checker[seed_index] == true) continue; checker[seed_index] = true; vector<Point> database_points = points_collection[seed_index]; float dist = compute_dtw_dist(points_current, database_points); if (dist < dist_min_selected) { dist_min_selected = dist; database_points_selected = database_points; } ++total_iterations; float dist_min = division_dist_min_checker.count(a) > 0 ? division_dist_min_checker[a] : 9999; if (dist >= dist_min) continue; dist_min = dist; while (dist_min_checker.count(dist_min) > 0) dist_min += 0.001; dist_min_checker[dist_min] = true; division_dist_min_checker[a] = dist_min; dist_min_division_checker[dist_min] = a; } } vector<float> dist_min_vec; for (int a = 0; a < (points_collection_size - 1); a += items_in_each_division) dist_min_vec.push_back(division_dist_min_checker[a]); std::sort(dist_min_vec.begin(), dist_min_vec.end(), decreasing()); int index = -1; for (float& dist_min : dist_min_vec) { ++index; dist_min_index_checker[dist_min] = index; } } Mat image_haha = Mat::zeros(HEIGHT_SMALL, WIDTH_SMALL, CV_8UC1); draw_contour(database_points_selected, image_haha, 254, 1, 0); imshow("image_haha", image_haha); waitKey(1); cout << total_iterations << endl; }
int _tmain(int argc, _TCHAR* argv[]) { // initModule_nonfree();//if use SIFT or SURF // Ptr<FeatureDetector> detector = FeatureDetector::create( "SIFT" ); // Ptr<DescriptorExtractor> descriptor_extractor = DescriptorExtractor::create( "SIFT" ); // Ptr<DescriptorMatcher> descriptor_matcher = DescriptorMatcher::create( "BruteForce" ); // if( detector.empty() || descriptor_extractor.empty() ) // throw runtime_error("fail to create detector!"); // // Mat img1 = imread("E:\\DayBreakZcs\\ImageProcessing\\source\\test3.jpg"); // Mat img2 = imread("E:\\DayBreakZcs\\ImageProcessing\\source\\test2.jpg"); // // //detect keypoints; // vector<KeyPoint> keypoints1,keypoints2; // detector->detect( img1, keypoints1 ); // detector->detect( img2, keypoints2 ); // cout <<"img1:"<< keypoints1.size() << " points img2:" <<keypoints2.size() // << " points" << endl << ">" << endl; // // //compute descriptors for keypoints; // cout << "< Computing descriptors for keypoints from images..." << endl; // Mat descriptors1,descriptors2; // descriptor_extractor->compute( img1, keypoints1, descriptors1 ); // descriptor_extractor->compute( img2, keypoints2, descriptors2 ); // // cout<<endl<<"Descriptors Size: "<<descriptors2.size()<<" >"<<endl; // cout<<endl<<"Descriptor's Column: "<<descriptors2.cols<<endl // <<"Descriptor's Row: "<<descriptors2.rows<<endl; // cout << ">" << endl; // // //Draw And Match img1,img2 keypoints // Mat img_keypoints1,img_keypoints2; // drawKeypoints(img1,keypoints1,img_keypoints1,Scalar::all(-1),0); // drawKeypoints(img2,keypoints2,img_keypoints2,Scalar::all(-1),0); // imshow("Box_in_scene keyPoints",img_keypoints1); // imshow("Box keyPoints",img_keypoints2); // // descriptor_extractor->compute( img1, keypoints1, descriptors1 ); // vector<DMatch> matches; // descriptor_matcher->match( descriptors1, descriptors2, matches ); // // Mat img_matches; // drawMatches(img1,keypoints1,img2,keypoints2,matches,img_matches,Scalar::all(-1),CV_RGB(255,255,255),Mat(),4); // // imshow("Mathc",img_matches); // waitKey(0); // return 0; // return 0; Mat image = imread("E:\\DayBreakZcs\\ImageProcessing\\source\\test4.jpg"); Mat descriptors; vector<KeyPoint> keypoints; SimpleBlobDetector::Params params; params.minThreshold = 10; params.maxThreshold = 100; params.thresholdStep = 10; params.minArea = 10; params.minConvexity = 0.3; params.minInertiaRatio = 0.01; params.maxArea = 8000; params.maxConvexity = 10; params.filterByColor = false; params.filterByCircularity = false; SimpleBlobDetector blobDetector( params ); blobDetector.create("SimpleBlob"); blobDetector.detect( image, keypoints ); drawKeypoints(image, keypoints, image, Scalar(255,0,0)); imshow("Mathc",image); waitKey(0); }