bool ObjPatchMatcher::Match(const Mat& cimg, const Mat& dmap_raw, Mat& mask_map) { /* * precompute feature maps */ // gradient Mat gray_img, gray_img_float, edge_map; cvtColor(cimg, gray_img, CV_BGR2GRAY); gray_img.convertTo(gray_img_float, CV_32F, 1.f/255); Canny(gray_img, edge_map, 10, 50); cv::imshow("edge", edge_map); cv::imshow("color", cimg); cv::waitKey(10); Mat grad_x, grad_y, grad_mag; Sobel(gray_img_float, grad_x, CV_32F, 1, 0); Sobel(gray_img_float, grad_y, CV_32F, 0, 1); magnitude(grad_x, grad_y, grad_mag); // depth Mat dmap_float, pts3d, normal_map; if( use_depth ) { Feature3D feat3d; dmap_raw.convertTo(dmap_float, CV_32F); Mat cmp_mask; compare(dmap_float, 800, cmp_mask, CMP_LT); dmap_float.setTo(800, cmp_mask); compare(dmap_float, 7000, cmp_mask, CMP_GT); dmap_float.setTo(7000, cmp_mask); dmap_float = (dmap_float-800)/(7000-800); feat3d.ComputeKinect3DMap(dmap_float, pts3d, false); feat3d.ComputeNormalMap(pts3d, normal_map); } /* * start searching */ // init searcher //searcher.Build(patch_data, BruteForce_L2); // opencv bfmatcher has size limit: maximum 2^31 LSHCoder lsh_coder; if(use_code) { lsh_coder.Load(); } Mat score_map = Mat::zeros(edge_map.rows, edge_map.cols, CV_32F); Mat mask_vote_map = Mat::zeros(cimg.rows, cimg.cols, CV_32F); mask_map = Mat::zeros(cimg.rows, cimg.cols, CV_32F); Mat mask_count = Mat::zeros(cimg.rows, cimg.cols, CV_32S); // number of mask overlapped on each pixel Mat feat; int topK = 40; int total_cnt = countNonZero(edge_map); vector<VisualObject> query_patches; query_patches.reserve(total_cnt); cout<<"Start match..."<<endl; float max_dist = 0; int cnt = 0; char str[30]; double start_t = getTickCount(); //#pragma omp parallel for for(int r=patch_size.height/2; r<gray_img.rows-patch_size.height/2; r+=3) { for(int c=patch_size.width/2; c<gray_img.cols-patch_size.width/2; c+=3) { /*int rand_r = rand()%gray_img.rows; int rand_c = rand()%gray_img.cols; if(rand_r < patch_size.height/2 || rand_r > gray_img.rows-patch_size.height/2 || rand_c < patch_size.width/2 || rand_c > gray_img.cols-patch_size.width/2) continue;*/ int rand_r = r, rand_c = c; if(edge_map.at<uchar>(rand_r, rand_c) > 0) { cnt++; destroyAllWindows(); Rect box(rand_c-patch_size.width/2, rand_r-patch_size.height/2, patch_size.width, patch_size.height); MatFeatureSet featset; gray_img_float(box).copyTo(featset["gray"]); //grad_mag(box).copyTo(featset["gradient"]); if(use_depth) { normal_map(box).copyTo(featset["normal"]); dmap_float(box).copyTo(featset["depth"]); } ComputePatchFeat(featset, feat); vector<DMatch> matches; if(use_code) { BinaryCodes codes; HashKey key_val; lsh_coder.ComputeCodes(feat, codes); HashingTools<HashKeyType>::CodesToKey(codes, key_val); MatchCode(key_val, topK, matches); } else { MatchPatch(feat, topK, matches); } if(matches[0].distance < 0 || matches[0].distance > 1000) { cout<<"match dist: "<<matches[0].distance<<endl; double minv, maxv; cout<<norm(feat, patch_data.row(matches[0].trainIdx), NORM_L2)<<endl; minMaxLoc(feat, &minv, &maxv); cout<<minv<<" "<<maxv<<endl; cout<<feat<<endl<<endl; minMaxLoc(patch_data.row(matches[0].trainIdx), &minv, &maxv); cout<<minv<<" "<<maxv<<endl; cout<<patch_data.row(matches[0].trainIdx)<<endl; imshow("cimg", cimg); waitKey(0); } vector<vector<Mat>> pixel_mask_vals(patch_size.height, vector<Mat>(patch_size.width, Mat::zeros(1, topK, CV_32F))); VisualObject cur_query; cur_query.visual_data.bbox = box; cur_query.visual_data.mask = Mat::zeros(patch_size.height, patch_size.width, CV_32F); for(size_t i=0; i<topK; i++) { score_map.at<float>(rand_r,rand_c) += matches[i].distance; cur_query.visual_data.mask += patch_meta.objects[matches[i].trainIdx].visual_data.mask; for(int mr=0; mr<patch_size.height; mr++) for(int mc=0; mc<patch_size.width; mc++) { pixel_mask_vals[mr][mc].at<float>(i) = patch_meta.objects[matches[i].trainIdx].visual_data.mask.at<float>(mr, mc); } } score_map.at<float>(rand_r,rand_c) /= topK; cur_query.visual_data.mask /= topK; // average returned mask // compute mask quality Scalar mean_, std_; /*ofstream out("pixel_mask_std_100.txt", ios::app); for(int mr=0; mr<patch_size.height; mr++) for(int mc=0; mc<patch_size.width; mc++) { meanStdDev(pixel_mask_vals[mr][mc], mean_, std_); out<<std_.val[0]<<" "; } out<<endl;*/ meanStdDev(cur_query.visual_data.mask, mean_, std_); cur_query.visual_data.scores.push_back(mean_.val[0]); cur_query.visual_data.scores.push_back(std_.val[0]); Mat align_mask = Mat::zeros(cimg.rows, cimg.cols, CV_8U); int gt_mask_id = patch_meta.objects[matches[0].trainIdx].meta_data.category_id; if(gt_mask_id != -1) { Mat nn_mask = gt_obj_masks[gt_mask_id]; //imshow("gt mask", nn_mask*255); //waitKey(10); Rect gt_box = patch_meta.objects[matches[0].trainIdx].visual_data.bbox; Rect align_box = AlignBox(box, gt_box, cimg.cols, cimg.rows); vector<ImgWin> boxes; boxes.push_back(align_box); //ImgVisualizer::DrawWinsOnImg("alignbox", cimg, boxes); //waitKey(10); Rect target_box = Rect(box.x-(gt_box.x-align_box.x), box.y-(gt_box.y-align_box.y), align_box.width, align_box.height); cout<<target_box<<endl; nn_mask(align_box).copyTo(align_mask(target_box)); } align_mask.convertTo(align_mask, CV_32F); mask_map += align_mask * matches[0].distance; //*score_map.at<float>(r,c); //mask_count(box) = mask_count(box) + 1; //cout<<score_map.at<float>(r,c)<<endl; max_dist = MAX(max_dist, matches[0].distance); query_patches.push_back(cur_query); // vote object regions /*Point3f line_ori; int obj_pt_sign; ComputeDominantLine(cur_query.visual_desc.mask, box.tl(), line_ori, obj_pt_sign); for(int rr=0; rr<cimg.rows; rr++) for(int cc=0; cc<cimg.cols; cc++) { float line_val = line_ori.x*cc+line_ori.y*rr+line_ori.z; if((line_val>0?1:-1)==obj_pt_sign) mask_vote_map.at<float>(rr, cc)++; }*/ #ifdef VERBOSE // current patch Mat disp, patch_gray, patch_grad, patch_normal, patch_depth; disp = cimg.clone(); rectangle(disp, box, CV_RGB(255,0,0), 2); resize(gray_img(box), patch_gray, Size(50,50)); resize(grad_mag(box), patch_grad, Size(50,50)); Mat cur_mask; resize(cur_query.visual_desc.mask, cur_mask, Size(50,50)); if(use_depth) { resize(normal_map(box), patch_normal, Size(50,50)); normalize(dmap_float(box), patch_depth, 1, 0, NORM_MINMAX); patch_depth.convertTo(patch_depth, CV_8U, 255); //dmap_float(box).convertTo(patch_depth, CV_8U, 255); resize(patch_depth, patch_depth, Size(50,50)); } Mat onormal; sprintf_s(str, "query_gray_%d.jpg", cnt); imshow(str, patch_gray); imwrite(str, patch_gray); /*sprintf_s(str, "query_grad_%d.jpg", cnt); ImgVisualizer::DrawFloatImg(str, patch_grad, onormal, true); imwrite(str, onormal);*/ sprintf_s(str, "query_depth_%d.jpg", cnt); imshow(str, patch_depth); imwrite(str, patch_depth); sprintf_s(str, "query_normal_%d.jpg", cnt); ImgVisualizer::DrawNormals(str, patch_normal, onormal, true); imwrite(str, onormal); sprintf_s(str, "query_box_%d.jpg", cnt); imshow(str, disp); imwrite(str, disp); //imshow("align mask", align_mask*255); cur_mask.convertTo(cur_mask, CV_8U, 255); sprintf_s(str, "query_tmask_%d.jpg", cnt); imshow(str, cur_mask); imwrite(str, cur_mask); // show match results vector<Mat> res_imgs(topK); vector<Mat> res_gradients(topK); vector<Mat> res_normals(topK); vector<Mat> res_depth(topK); vector<Mat> db_boxes(topK); vector<Mat> res_masks(topK); for(size_t i=0; i<topK; i++) { VisualObject& cur_obj = patch_meta.objects[matches[i].trainIdx]; // mask cur_obj.visual_desc.mask.convertTo(res_masks[i], CV_8U, 255); // gray cur_obj.visual_desc.extra_features["gray"].convertTo(res_imgs[i], CV_8U, 255); // gradient //ImgVisualizer::DrawFloatImg("", cur_obj.visual_desc.extra_features["gradient"], res_gradients[i], false); // 3D if(use_depth) { // normal tools::ImgVisualizer::DrawNormals("", cur_obj.visual_desc.extra_features["normal"], res_normals[i]); // depth normalize(cur_obj.visual_desc.extra_features["depth"], res_depth[i], 1, 0, NORM_MINMAX); res_depth[i].convertTo(res_depth[i], CV_8U, 255); //cur_obj.visual_desc.extra_features["depth"].convertTo(res_depth[i], CV_8U, 255); } // box on image db_boxes[i] = imread(patch_meta.objects[matches[i].trainIdx].imgpath); resize(db_boxes[i], db_boxes[i], Size(cimg.cols, cimg.rows)); rectangle(db_boxes[i], patch_meta.objects[matches[i].trainIdx].visual_desc.box, CV_RGB(255,0,0), 2); } Mat out_img; sprintf_s(str, "res_gray_%d.jpg", cnt); ImgVisualizer::DrawImgCollection(str, res_imgs, topK, Size(50,50), out_img); imwrite(str, out_img); sprintf_s(str, "res_normal_%d.jpg", cnt); ImgVisualizer::DrawImgCollection(str, res_normals, topK, Size(50,50), out_img); imwrite(str, out_img); sprintf_s(str, "res_depth_%d.jpg", cnt); ImgVisualizer::DrawImgCollection(str, res_depth, topK, Size(50,50), out_img); imwrite(str, out_img); /*sprintf_s(str, "res_gradient_%d.jpg", cnt); tools::ImgVisualizer::DrawImgCollection(str, res_gradients, topK, Size(50,50), out_img); imwrite(str, out_img);*/ sprintf_s(str, "res_mask_%d.jpg", cnt); tools::ImgVisualizer::DrawImgCollection(str, res_masks, topK, Size(50,50), out_img); imwrite(str, out_img); sprintf_s(str, "res_box_%d.jpg", cnt); tools::ImgVisualizer::DrawImgCollection(str, db_boxes, topK/2, Size(200, 200), out_img); imwrite(str, out_img); waitKey(0); #endif cout<<total_cnt--<<endl; } } } cout<<"match done. Time cost: "<<(getTickCount()-start_t)/getTickFrequency()<<"s."<<endl; //score_map(Rect(patch_size.width/2, patch_size.height/2, score_map.cols-patch_size.width/2, score_map.rows-patch_size.height/2)).copyTo(score_map); //score_map.setTo(max_dist, 255-edge_map); normalize(score_map, score_map, 1, 0, NORM_MINMAX); score_map = 1-score_map; //tools::ImgVisualizer::DrawFloatImg("bmap", score_map); mask_map /= max_dist; cout<<max_dist<<endl; normalize(mask_map, mask_map, 1, 0, NORM_MINMAX); //tools::ImgVisualizer::DrawFloatImg("maskmap", mask_map); //normalize(mask_vote_map, mask_vote_map, 1, 0, NORM_MINMAX); //ImgVisualizer::DrawFloatImg("vote map", mask_vote_map); //waitKey(0); return true; // pick top weighted points to see if they are inside objects // try graph-cut for region proposal // among all retrieved mask patch, select most discriminative one and do graph-cut sort(query_patches.begin(), query_patches.end(), [](const VisualObject& a, const VisualObject& b) { return a.visual_data.scores[1] > b.visual_data.scores[1]; }); for(size_t i=0; i<query_patches.size(); i++) { Mat disp_img = cimg.clone(); rectangle(disp_img, query_patches[i].visual_data.bbox, CV_RGB(255,0,0)); imshow("max std box", disp_img); Mat big_mask; resize(query_patches[i].visual_data.mask, big_mask, Size(50,50)); ImgVisualizer::DrawFloatImg("max std mask", big_mask); waitKey(0); // use mask to do graph-cut Mat fg_mask(cimg.rows, cimg.cols, CV_8U); fg_mask.setTo(cv::GC_PR_FGD); Mat th_mask; threshold(query_patches[i].visual_data.mask, th_mask, query_patches[i].visual_data.scores[0], 1, CV_THRESH_BINARY); th_mask.convertTo(th_mask, CV_8U); fg_mask(query_patches[i].visual_data.bbox).setTo(cv::GC_FGD, th_mask); th_mask = 1-th_mask; fg_mask(query_patches[i].visual_data.bbox).setTo(cv::GC_BGD, th_mask); cv::grabCut(cimg, fg_mask, Rect(0,0,1,1), Mat(), Mat(), 3, cv::GC_INIT_WITH_MASK); fg_mask = fg_mask & 1; disp_img.setTo(Vec3b(0,0,0)); cimg.copyTo(disp_img, fg_mask); cv::imshow("cut", disp_img); cv::waitKey(0); } float ths[] = {0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f}; for(size_t i=0; i<8; i++) { Mat th_mask; threshold(mask_map, th_mask, ths[i], 1, CV_THRESH_BINARY); char str[30]; sprintf_s(str, "%f", ths[i]); ImgVisualizer::DrawFloatImg(str, th_mask); waitKey(0); } return true; }
vector<PlateRegion> DetectorMorph::detect(Mat frame, std::vector<cv::Rect> regionsOfInterest) { Mat frame_gray,frame_gray_cp; if (frame.channels() > 2) { cvtColor( frame, frame_gray, CV_BGR2GRAY ); } else { frame.copyTo(frame_gray); } frame_gray.copyTo(frame_gray_cp); blur(frame_gray, frame_gray, Size(5, 5)); vector<PlateRegion> detectedRegions; for (int i = 0; i < regionsOfInterest.size(); i++) { Mat img_open, img_result; Mat element = getStructuringElement(MORPH_RECT, Size(30, 4)); morphologyEx(frame_gray, img_open, CV_MOP_OPEN, element, cv::Point(-1, -1)); img_result = frame_gray - img_open; if (config->debugDetector && config->debugShowImages) { imshow("Opening", img_result); } //threshold image using otsu thresholding Mat img_threshold, img_open2; threshold(img_result, img_threshold, 0, 255, CV_THRESH_OTSU + CV_THRESH_BINARY); if (config->debugDetector && config->debugShowImages) { imshow("Threshold Detector", img_threshold); } Mat diamond(5, 5, CV_8U, cv::Scalar(1)); diamond.at<uchar>(0, 0) = 0; diamond.at<uchar>(0, 1) = 0; diamond.at<uchar>(1, 0) = 0; diamond.at<uchar>(4, 4) = 0; diamond.at<uchar>(3, 4) = 0; diamond.at<uchar>(4, 3) = 0; diamond.at<uchar>(4, 0) = 0; diamond.at<uchar>(4, 1) = 0; diamond.at<uchar>(3, 0) = 0; diamond.at<uchar>(0, 4) = 0; diamond.at<uchar>(0, 3) = 0; diamond.at<uchar>(1, 4) = 0; morphologyEx(img_threshold, img_open2, CV_MOP_OPEN, diamond, cv::Point(-1, -1)); Mat rectElement = getStructuringElement(cv::MORPH_RECT, Size(13, 4)); morphologyEx(img_open2, img_threshold, CV_MOP_CLOSE, rectElement, cv::Point(-1, -1)); if (config->debugDetector && config->debugShowImages) { imshow("Close", img_threshold); waitKey(0); } //Find contours of possibles plates vector< vector< Point> > contours; findContours(img_threshold, contours, // a vector of contours CV_RETR_EXTERNAL, // retrieve the external contours CV_CHAIN_APPROX_NONE); // all pixels of each contours //Start to iterate to each contour founded vector<vector<Point> >::iterator itc = contours.begin(); vector<RotatedRect> rects; //Remove patch that are no inside limits of aspect ratio and area. while (itc != contours.end()) { //Create bounding rect of object RotatedRect mr = minAreaRect(Mat(*itc)); if (mr.angle < -45.) { mr.angle += 90.0; swap(mr.size.width, mr.size.height); } if (!CheckSizes(mr)) itc = contours.erase(itc); else { ++itc; rects.push_back(mr); } } //Now prunning based on checking all candidate plates for a min/max number of blobsc Mat img_crop, img_crop_b, img_crop_th, img_crop_th_inv; vector< vector< Point> > plateBlobs; vector< vector< Point> > plateBlobsInv; double thresholds[] = { 10, 40, 80, 120, 160, 200, 240 }; const int num_thresholds = 7; int numValidChars = 0; Mat rotated; for (int i = 0; i < rects.size(); i++) { numValidChars = 0; RotatedRect PlateRect = rects[i]; Size rect_size = PlateRect.size; // get the rotation matrix Mat M = getRotationMatrix2D(PlateRect.center, PlateRect.angle, 1.0); // perform the affine transformation warpAffine(frame_gray_cp, rotated, M, frame_gray_cp.size(), INTER_CUBIC); //Crop area around candidate plate getRectSubPix(rotated, rect_size, PlateRect.center, img_crop); if (config->debugDetector && config->debugShowImages) { imshow("Tilt Correction", img_crop); waitKey(0); } for (int z = 0; z < num_thresholds; z++) { cv::threshold(img_crop, img_crop_th, thresholds[z], 255, cv::THRESH_BINARY); cv::threshold(img_crop, img_crop_th_inv, thresholds[z], 255, cv::THRESH_BINARY_INV); findContours(img_crop_th, plateBlobs, // a vector of contours CV_RETR_LIST, // retrieve the contour list CV_CHAIN_APPROX_NONE); // all pixels of each contours findContours(img_crop_th_inv, plateBlobsInv, // a vector of contours CV_RETR_LIST, // retrieve the contour list CV_CHAIN_APPROX_NONE); // all pixels of each contours int numBlobs = plateBlobs.size(); int numBlobsInv = plateBlobsInv.size(); float idealAspect = config->charWidthMM / config->charHeightMM; for (int j = 0; j < numBlobs; j++) { cv::Rect r0 = cv::boundingRect(cv::Mat(plateBlobs[j])); if (ValidateCharAspect(r0, idealAspect)) numValidChars++; } for (int j = 0; j < numBlobsInv; j++) { cv::Rect r0 = cv::boundingRect(cv::Mat(plateBlobsInv[j])); if (ValidateCharAspect(r0, idealAspect)) numValidChars++; } } //If too much or too lcittle might not be a true plate //if (numBlobs < 3 || numBlobs > 50) continue; if (numValidChars < 4 || numValidChars > 50) continue; PlateRegion PlateReg; // Ensure that the rectangle isn't < 0 or > maxWidth/Height Rect bounding_rect = PlateRect.boundingRect(); PlateReg.rect = expandRect(bounding_rect, 0, 0, frame.cols, frame.rows); detectedRegions.push_back(PlateReg); } } return detectedRegions; }
fVector4 CamSparseFlow::detect(CamFrame* pFrame) { #ifdef USE_CUDA GpuMat d_prevPts; GpuMat d_nextPts; GpuMat d_status; Mat dMat, tMat; vector<Point2f> prevPts; vector<Point2f> nextPts; vector<uchar> status; int i; int numPts; int numV; cv::Point p, q; double dX, dY; double distSQ, distSQTotal, absXtot, absYtot; double distSQMin; double distSQMax; double vBase; distSQMin = 1; distSQMax = (pFrame->m_width + pFrame->m_height)*0.15; distSQMax *= distSQMax; m_pDetector->detect(*(pFrame->m_pPrev), d_prevPts); m_pPyrLK->calc( *(pFrame->m_pPrev), *(pFrame->m_pNext), d_prevPts, d_nextPts, d_status); prevPts.resize(d_prevPts.cols); tMat = Mat(1, d_prevPts.cols, CV_32FC2, (void*)&prevPts[0]); d_prevPts.download(tMat); nextPts.resize(d_nextPts.cols); tMat = Mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]); d_nextPts.download(tMat); status.resize(d_status.cols); tMat = Mat(1, d_status.cols, CV_8UC1, (void*)&status[0]); d_status.download(tMat); //Find the flow direction m_flow.m_x = 0; m_flow.m_y = 0; m_flow.m_z = 0; m_flow.m_w = 0; absXtot = 0.0; absYtot = 0.0; numPts = prevPts.size(); numV = 0; for ( i = 0; i < numPts; i++) { if (!status[i])continue; p = prevPts[i]; q = nextPts[i]; dX = q.x - p.x; dY = q.y - p.y; distSQ = dX*dX + dY*dY; if (distSQ < distSQMin)continue; if (distSQ > distSQMax)continue; m_flow.m_x += dX; m_flow.m_y += dY; absXtot += abs(dX); absYtot += abs(dY); numV++; } //Calc the motion vector vBase = 1.0/(double)numV; distSQTotal = absXtot*absXtot + absYtot*absYtot; m_flow.m_x *= vBase; m_flow.m_y *= vBase; m_flow.m_z = 0; //TODO: Change in Height m_flow.m_w = 0; //TODO: Rotation return m_flow; #if (SHOW_FEATURE_FLOW==1) m_Mat.m_pNew->download(dMat); p = Point(mSize.width / 2, mSize.height / 2); q = p + Point(m_flow.m_x, m_flow.m_y); line(dMat, p, q, Scalar(0,255,0), 3); // drawFeatureFlow(dMat, prevPts, nextPts, status, Scalar(255, 0, 0)); imshow(CF_WINDOW, dMat); #endif #else m_pDetector->detect(m_Mat.m_uFrame, m_keypoint1); m_pDetector->detect(m_Mat.m_uFrame, m_keypoint2); m_pExtractor->compute(m_Mat.m_uFrame, m_keypoint1, m_descriptor1); m_pExtractor->compute(m_Mat.m_uFrame, m_keypoint2, m_descriptor2); m_pMatcher->match(m_descriptor1, m_descriptor2, m_dMatch); #endif }
#include "base64.h" #include "TouchPlus.h" #define TP_CAMERA_VID "1e4e" #define TP_CAMERA_PID "0107" #define USE_DIRECT_SHOW 0 #define BYTE unsigned char * bool Camera::ready = false; bool Camera::opened = false; function<void (Mat& image_in)> Camera::callback; //static RactivJPEGDecompressor * decomp = new RactivJPEGDecompressor(); unsigned char * myBuffer; Mat image_out = Mat(480, 1280, CV_8UC3); static char fname[256]; long long s_upload_file_size = 0; bool ZipFile(const std::vector<std::string>& sourceFiles, char * destZip); void * pHandle = NULL; Camera::Camera(){} Camera::Camera(bool _useMJPEG, int _width, int _height, function<void (Mat& image_in)> callback_in) { height = _height; width = _width; useMJPEG = _useMJPEG; callback = callback_in;
Mat TableObjectDetector::clusterObjects(Mat P, int K, bool removeOutliers) { Mat L; int attempts = 5; P.convertTo(P, CV_32F); kmeans(P, K, L, TermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 10000, 0.0001), attempts, KMEANS_PP_CENTERS); // We remove outliers that are outside a number of standard deviations away // from the object centroid. We do this by just setting their cluster label // to -1 if (removeOutliers) { float numStdDevs = 3; float maxDist = 0.1; // Caluclate centroids vector<Mat> clusterData; Mat clusterCentroids(K, 3, CV_32F); for (int k=0; k<K; k++) { Mat D = Mat(0, 3, CV_64F); for (int i=0; i<L.rows; i++) { if (L.at<int>(i)==k) { D.push_back(P.row(i)); } } clusterData.push_back(D); reduce(D, clusterCentroids.row(k), 0, CV_REDUCE_AVG); } // Now calculate distances of each point, and the std. devs. of each // cluster Mat Dist = Mat::zeros(P.rows, 1, CV_32F); vector<Mat> centroidDistances; for (int k=0; k<K; k++) { centroidDistances.push_back(Mat(0, 1, CV_32F)); } for (int i=0; i<L.rows; i++) { Mat centroid = clusterCentroids.row(L.at<int>(i)); Mat pt = P.row(i); int k = L.at<int>(i); float d = std::sqrt( std::pow(pt.at<float>(0) - centroid.at<float>(0), 2) + std::pow(pt.at<float>(1) - centroid.at<float>(1), 2) + std::pow(pt.at<float>(2) - centroid.at<float>(2), 2) ); Dist.at<float>(i) = d; centroidDistances.at(k).push_back(d); } for (int k=0; k<K; k++) { Mat ignore; Mat std_dev; meanStdDev(centroidDistances.at(k), ignore, std_dev); float k_std = std_dev.at<Scalar>(0)(0); for (int i=0; i<P.rows; i++) { if (L.at<int>(i) == k) { //if (Dist.at<float>(i) > numStdDevs*k_std) { if (Dist.at<float>(i) > maxDist) { L.at<int>(i) = -1; } } } } // Now compute standard deviations for all clusters //Mat centroidStdDevs = Mat::zeros(K, 1); //for (int k=0; k<K; k++) { //} } return L; }
void computeChannels(InputArray image, vector<Mat>& channels) { Mat_<float> grad; Mat_<float> angles; Mat luv, gray, src; if(image.getMat().channels() > 1) { src = Mat(image.getMat().rows, image.getMat().cols, CV_32FC3); image.getMat().convertTo(src, CV_32FC3, 1./255); cvtColor(src, gray, CV_RGB2GRAY); cvtColor(src, luv, CV_RGB2Luv); } else { src = Mat(image.getMat().rows, image.getMat().cols, CV_32FC1); image.getMat().convertTo(src, CV_32FC1, 1./255); src.copyTo(gray); } Mat_<float> row_der, col_der; Sobel(gray, row_der, CV_32F, 0, 1); Sobel(gray, col_der, CV_32F, 1, 0); cartToPolar(col_der, row_der, grad, angles, true); //magnitude(row_der, col_der, grad); Mat_<Vec6f> hist = Mat_<Vec6f>::zeros(grad.rows, grad.cols); //const float to_deg = 180 / 3.1415926f; for (int row = 0; row < grad.rows; ++row) { for (int col = 0; col < grad.cols; ++col) { //float angle = atan2(row_der(row, col), col_der(row, col)) * to_deg; float angle = angles(row, col); if (angle < 0) angle += 180; int ind = (int)(angle / 30); // If angle == 180, prevent index overflow if (ind == 6) ind = 5; hist(row, col)[ind] = grad(row, col) * 255; } } channels.clear(); if(image.getMat().channels() > 1) { Mat luv_channels[3]; split(luv, luv_channels); for( int i = 0; i < 3; ++i ) channels.push_back(luv_channels[i]); } channels.push_back(grad); vector<Mat> hist_channels; split(hist, hist_channels); for( size_t i = 0; i < hist_channels.size(); ++i ) channels.push_back(hist_channels[i]); }
std::vector<std::vector<std::vector<cv::Point>>> MultiContourObjectDetector::findApproxContours( cv::Mat image, bool performOpening, bool findBaseShape) { // CREATE ACTIVE ZONE 80% AND 50% --------------------- Point centre(image.size().width / 2, image.size().height / 2); int deleteHeight = image.size().height * _deleteFocus; int deleteWidth = image.size().width * _deleteFocus; int deleteX = centre.x - deleteWidth / 2; int deleteY = centre.y - deleteHeight / 2; int attenuationHeight = image.size().height * _attenuationFocus; int attenuationWidth = image.size().width * _attenuationFocus; int attenuationX = centre.x - attenuationWidth / 2; int attenuationY = centre.y - attenuationHeight / 2; Rect erase(deleteX, deleteY, deleteWidth, deleteHeight); _deleteRect = erase; Rect ease(attenuationX, attenuationY, attenuationWidth, attenuationHeight); _attenuationRect = ease; // ---------------------------------------- bool imageTooBig = false; Mat newImage; if (image.size().height <= 400 || image.size().width <= 400) { Mat pickColor = image(Rect((image.size().width / 2) - 1, image.size().height - 2, 2, 2)); Scalar color = mean(pickColor); int increment = 2; newImage = Mat(Size(image.size().width + increment, image.size().height + increment), image.type()); newImage = color; Point nc(newImage.size().width / 2, newImage.size().height / 2); int incH = image.size().height; int incW = image.size().width; int incX = nc.x - incW / 2; int incY = nc.y - incH / 2; image.copyTo(newImage(Rect(incX, incY, incW, incH))); } else { imageTooBig = true; newImage = image; } Size imgSize = newImage.size(); Mat gray(imgSize, CV_8UC1); Mat thresh(imgSize, CV_8UC1); if (newImage.channels() >= 3) cvtColor(newImage, gray, CV_BGR2GRAY); else newImage.copyTo(gray); int minThreshold; if (performOpening) { // PERFORM OPENING (Erosion --> Dilation) int erosion_size = 3; int dilation_size = 3; if (imageTooBig) { erosion_size = 5; dilation_size = 5; } Mat element = getStructuringElement(0, Size(2 * erosion_size, 2 * erosion_size), Point(erosion_size, erosion_size)); erode(gray, gray, element); dilate(gray, gray, element); minThreshold = mean(gray)[0]; if (minThreshold < 90) minThreshold = 60; else if (minThreshold >= 90 && minThreshold < 125) minThreshold = 100; } threshold(gray, thresh, minThreshold, 255, THRESH_BINARY); #ifdef DEBUG_MODE imshow("Threshold", thresh); #endif vector<vector<Point>> contours; vector<Vec4i> hierarchy; vector<Point> hull, approx; map<int, vector<vector<Point>>> hierachedContours; map<int, vector<vector<Point>>> approxHContours; findContours(thresh, contours, hierarchy, CV_RETR_TREE, CHAIN_APPROX_NONE); #ifdef DEBUG_MODE Mat tempI(image.size(), CV_8UC1); tempI = Scalar(0); drawContours(tempI, contours, -1, cv::Scalar(255), 1, CV_AA); imshow("Contours", tempI); #endif vector<vector<Point>> temp; // CATALOG BY HIERARCHY LOOP for (int i = 0; i < contours.size(); i++) { #ifdef DEBUG_MODE tempI = Scalar(0); temp.clear(); temp.push_back(contours[i]); drawContours(tempI, temp, -1, cv::Scalar(255), 1, CV_AA); #endif int parent = hierarchy[i][3]; if (parent == -1) { if (hierachedContours.count(i) == 0) { // me not found hierachedContours.insert(pair<int, vector<vector<Point>>>(i, vector<vector<Point>>())); hierachedContours[i].push_back(contours[i]); } else { // me found continue; } } else { if (hierachedContours.count(parent) == 0) { // dad not found hierachedContours.insert(pair<int, vector<vector<Point>>>(parent, vector<vector<Point>>())); hierachedContours[parent].push_back(contours[parent]); } hierachedContours[parent].push_back(contours[i]); } } int minPoint, maxPoint; minPoint = _minContourPoints - _minContourPoints / 2.1; maxPoint = _minContourPoints + _minContourPoints / 1.5; // APPROX LOOP for (map<int, vector<vector<Point>>>::iterator it = hierachedContours.begin(); it != hierachedContours.end(); it++) { if (it->second[0].size() < 400) continue; #ifdef DEBUG_MODE tempI = Scalar(0); drawContours(tempI, it->second, -1, cv::Scalar(255), 1, CV_AA); #endif if (it == hierachedContours.begin() && it->second.size() < _aspectedContours) continue; for (int k = 0; k < it->second.size(); k++) { if (it->second[k].size() < _minContourPoints) { if (k == 0) // padre break; else // figlio continue; } convexHull(it->second[k], hull, false); double epsilon = it->second[k].size() * 0.003; approxPolyDP(it->second[k], approx, epsilon, true); #ifdef DEBUG_MODE tempI = Scalar(0); vector<vector<Point>> temp; temp.push_back(approx); drawContours(tempI, temp, -1, cv::Scalar(255), 1, CV_AA); #endif // REMOVE TOO EXTERNAL SHAPES ------------- if (imageTooBig) { Rect bounding = boundingRect(it->second[k]); #ifdef DEBUG_MODE rectangle(tempI, _deleteRect, Scalar(255)); rectangle(tempI, bounding, Scalar(255)); #endif bool isInternal = bounding.x > _deleteRect.x && bounding.y > _deleteRect.y && bounding.x + bounding.width < _deleteRect.x + _deleteRect.width && bounding.y + bounding.height < _deleteRect.y + _deleteRect.height; if (!isInternal) { if (k == 0) break; } } // -------------------------------------------------- if (!findBaseShape) { if (hull.size() < minPoint || hull.size() > maxPoint) { if (k == 0) // padre break; else // figlio continue; } } if (k == 0) { approxHContours.insert(pair<int, vector<vector<Point>>>(it->first, vector<vector<Point>>())); approxHContours.at(it->first).push_back(approx); } else { approxHContours[it->first].push_back(approx); } } } int maxSize = 0, maxID = 0; vector<vector<vector<Point>>> lookupVector; for (map<int, vector<vector<Point>>>::iterator it = approxHContours.begin(); it != approxHContours.end(); it++) { if (it->second.size() <= 1) continue; if (findBaseShape) { int totSize = 0; for (int k = 0; k < it->second.size(); k++) { totSize += it->second[k].size(); } if (totSize > maxSize) { maxSize = totSize; maxID = it->first; } } else { lookupVector.push_back(it->second); } } if (findBaseShape) { lookupVector.push_back(approxHContours.at(maxID)); } return lookupVector; }
static void doIteration(Mat& img1, Mat& img2, vector<int>& queryIdxs, vector<int>& trainIdxs, Ptr<DescriptorMatcher>& descriptorMatcher, int matcherFilter,vector<KeyPoint>& keypoints1, Mat& descriptors1, vector<KeyPoint>& keypoints2,Mat& descriptors2, Mat& matchedDesc1, Mat& matchedDesc2, vector<Point2f>& matchedPoints1, vector<Point2f>& matchedPoints2, vector<Point2f>& MP1, vector<KeyPoint>& tempkey) { assert( !img2.empty()); cv::SURF mySURF; mySURF.extended = 0; Mat H12; mySURF.detect(img2, keypoints2); mySURF.compute(img2, keypoints2, descriptors2); vector<DMatch> filteredMatches; switch( matcherFilter ) { case CROSS_CHECK_FILTER : crossCheckMatching( descriptorMatcher, descriptors1, descriptors2, filteredMatches, 1 ); break; default : simpleMatching( descriptorMatcher, descriptors1, descriptors2, filteredMatches ); } trainIdxs.clear(); queryIdxs.clear(); for( size_t i = 0; i < filteredMatches.size(); i++ ) { queryIdxs.push_back(filteredMatches[i].queryIdx); trainIdxs.push_back(filteredMatches[i].trainIdx); } ////// Mat mDesc1, mDesc2; for(size_t i=0; i<queryIdxs.size(); i++) { mDesc1.push_back(descriptors1.row(queryIdxs[i])); mDesc2.push_back(descriptors2.row(trainIdxs[i])); } vector<Point2f> points1; KeyPoint::convert(keypoints1, points1, queryIdxs); vector<Point2f> points2; KeyPoint::convert(keypoints2, points2, trainIdxs); vector<char> matchesMask( filteredMatches.size(), 0 );//, matchesMask2( filteredMatches.size(), 1 );; Mat drawImg;// drawImg2; cout << "points2.size \t" << points2.size() << endl; cout <<"HELLO \t" << endl; if( RANSAC_THREHOLD >= 0 ) { if (points2.size() < 4 ) { cout << "matchedPoints1 less than 4, hence prev ROI is retained" << endl; for(size_t i1=0;i1<points2.size();i1++) { matchesMask[i1] = 1; matchedPoints1.push_back( points1[i1]); matchedPoints2.push_back( points2[i1]); matchedDesc1.push_back(descriptors1.row(queryIdxs[i1])); matchedDesc2.push_back(descriptors2.row(trainIdxs[i1])); tempkey.push_back(keypoints2[trainIdxs[i1]]); MP1.push_back(points2[i1]); } } else { H12 = findHomography( Mat(points1), Mat(points2), CV_RANSAC, RANSAC_THREHOLD ); if( !H12.empty() ) { Mat points1t; perspectiveTransform(Mat(points1), points1t, H12); vector<Point2f> points2Shift(points2.size()); points2Shift = points2; shiftPoints(points2Shift, box); Point2f boxCenter; boxCenter.x = box.x + box.width/2; boxCenter.y = box.y + box.height/2; for( size_t i1 = 0; i1 < points1.size(); i1++ ) { double descDiff = pow(norm(mDesc1.row(i1) - mDesc2.row(i1)) , 2); // if(descDiff < 0.08) { double diff = norm(points2[i1] - points1t.at<Point2f>((int)i1,0)); if(diff <= 30) { // cout << diff << endl; matchesMask[i1] = 1; matchedPoints1.push_back( points1[i1]); matchedPoints2.push_back( points2[i1]); matchedDesc1.push_back(descriptors1.row(queryIdxs[i1])); matchedDesc2.push_back(descriptors2.row(trainIdxs[i1])); tempkey.push_back(keypoints2[trainIdxs[i1]]); MP1.push_back(points2[i1]); } } } } // drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg2, CV_RGB(255, 255, 0), CV_RGB(255,255, 255), matchesMask2 // #if DRAW_RICH_KEYPOINTS_MODE // , DrawMatchesFlags::DRAW_RICH_KEYPOINTS // #endif // ); drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255), matchesMask #if DRAW_RICH_KEYPOINTS_MODE , DrawMatchesFlags::DRAW_RICH_KEYPOINTS #endif ); cout << endl; imshow( "doiter", drawImg ); // Mat newimg = img1.clone(); // KeyPoint::convert(keypoints1, points1); // for(size_t i=0;i<points1.size();i++) // circle(newimg, points1[i], 2, Scalar(255,0,255),2); // imshow( "doimg", newimg ); // points1.clear(); // waitKey(0); } } // waitKey(0); }
int main(int argc, char** argv) { ofstream f1; f1.open("result.txt"); size_t i,j; Point2f cp; cv::initModule_nonfree(); vector<Point2f> MP1,MP2; vector<int> trainIdxs, queryIdxs; //Read Video File VideoCapture cap("video1.avi"); if( !cap.isOpened() ) { cout << "Could not initialize capturing...\n"; return 0;} VideoWriter writer("ms_tracking.avi",CV_FOURCC('D','I','V','3'), 10,cvSize(640,480),1); cv::SURF mySURF; mySURF.extended = 0; Ptr<DescriptorMatcher> descriptorMatcher = DescriptorMatcher::create( "FlannBased" ); int mactherFilterType = getMatcherFilterType( "CrossCheckFilter" ); Mat frame,img1,img2; cap >> frame; if( frame.empty() ) return -1; img1 = frame.clone() ; Mat temp,temp1; if(img1.empty()) cout << "Exiting as the input image is empty" << endl; const char* name = "Initiate_ROI"; box = cvRect(-1,-1,0,0); cvNamedWindow( name,1); cvSetMouseCallback( name, my_mouse_callback2); // Main loop while( 1 ) { img1.copyTo(temp); if( drawing_poly) { for ( i=0; i < polyPoints.size(); i++) circle(temp, polyPoints[i], 2, Scalar(0,255,0), -1,8); } cv::imshow(name,temp) ; char c = (char)waitKey(10); if( c == '\x1b' ) // esc break; if(poly_drawn) break; } //Read the polygon points from a text file FILE *f11; polyPoints.clear(); IpolyPoints.clear(); f11 = fopen("points.txt","r"); Point a; for(int j=0;j<37;j++) { fscanf(f11,"%d",&(a.x)); fscanf(f11,"%d",&(a.y)); polyPoints.push_back(a); IpolyPoints.push_back(a); } fclose(f11); // Drawing Polygon Point pointArr[polyPoints.size()]; for (i=0; i< polyPoints.size(); i++) pointArr[i] = polyPoints[i]; const Point* pointsArray[1] = {pointArr}; int nCurvePts[1] = { polyPoints.size() }; polylines(temp, pointsArray, nCurvePts, 1, 1, Scalar(0,255,0), 1); cout << polyPoints.size() << endl; box= boundingRect(polyPoints); //boxOrg = Rect(box.x-15, box.y-15, box.width+30, box.height+30); boxOuter = Rect(box.x-30, box.y-30, box.width+60, box.height+60); //box =boxOrg; // storing the initial selected Box, as "box" variable changes in consecutive matching boxP=box; Mat img1ROI, labels1, clusters1, descriptors,roidescriptors, descriptors1,bdescriptors, bmdescriptors; vector<int> reprojections; // number of reprojections per KP, size same as KP(incresing) vector<Point2f> points,points1,points2, Mpoints1,Mpoints2,bpoints,npoints1,npoints2; //bmpoints,tpoints; vector<KeyPoint> roikeypoints, bkeypoints,keypoints,keypoints1, keypoints2; draw_box(temp, box ); //Show InnerBox - This is used by the Mean-Shift Tracker draw_box(temp,boxOuter); //Show OuterBox - This is used for removing background points bpoints.clear(); //calculating keypoints and descriptors of the selected polygon in image roi //==============================================================================================// for(i=0;i<polyPoints.size();i++) { // cout << polyPoints[i] << endl; // polyPoints[i].x = polyPoints[i].x -boxOuter.x; polyPoints[i].y = polyPoints[i].y- boxOuter.y; } img1ROI = img1(boxOuter); points1.clear(); mySURF.detect(img1ROI, roikeypoints); KeyPoint::convert(roikeypoints, points); mySURF.compute(img1ROI, roikeypoints, roidescriptors); bdescriptors.release();bkeypoints.clear(); bcategorizePoints( points, bpoints,polyPoints, roikeypoints, roidescriptors, bkeypoints, bdescriptors); shiftPoints(bpoints,boxOuter); for(i=0;i<bpoints.size();i++) circle(temp, bpoints[i], 2, Scalar(0,255,0),2); vector<KeyPoint> tpkeypoints; Mat tpdescriptors; categorizePoints( points, points1,polyPoints, roikeypoints, roidescriptors, tpkeypoints, tpdescriptors); shiftPoints(points1, boxOuter); for(i=0;i<points1.size();i++) circle(temp, points1[i], 2, Scalar(0,0,255),2); //====================================================================================================// points1.clear(); Mat img2ROI; // tpkeypoints = keypoints1; tpdescriptors = descriptors1; cv::imshow(name,temp) ; imwrite("a.jpg",temp); cout << "BD_SIZE \t" << bdescriptors.rows << "\t" << "FD_SIZE \t" << tpdescriptors.rows << endl; // Mat newimg = img1ROI.clone(); // KeyPoint::convert(tpkeypoints, points1); // for(size_t i=0;i<points1.size();i++) // circle(newimg, points1[i], 2, Scalar(255,0,255),2); // imshow( "newimg", newimg ); // points1.clear(); waitKey(0); cvDestroyWindow( name ); int FG_mp, FG, BG_mp, BG, FG_BG, msI ; //Foreground matching points struct timeval t1, t2; for(int l=0;;l++) { gettimeofday(&t1, NULL); cv::kmeans(tpdescriptors, NOC, labels1, TermCriteria( CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 50, 1.0 ), 1, KMEANS_RANDOM_CENTERS, clusters1); cap >> frame; img2 = frame.clone() ; temp1 =frame.clone() ; if(img2.empty() ) { cout<< "Could not open image: " << endl ; break;} int flag=1; Mpoints1.clear(); Mat descriptors2; msI=0; meanShift(img1, img2, descriptorMatcher, mactherFilterType, tpkeypoints, tpdescriptors,keypoints2,descriptors2, clusters1, cp, flag, MP1,img2ROI,bkeypoints, bdescriptors, temp1,FG_mp, FG, BG_mp, BG, FG_BG,msI); //==========scaling================= float scale=1; // cout <<"MP1size \t" << MP1.size() <<endl; if(APPLY_SCALING) { vector<DMatch> filteredMatches; if(descriptors1.rows > 4 && descriptors2.rows > 4) { crossCheckMatching( descriptorMatcher, descriptors1, descriptors2, filteredMatches, 1 ); trainIdxs.clear(); queryIdxs.clear(); for( i = 0; i < filteredMatches.size(); i++ ) { queryIdxs.push_back(filteredMatches[i].queryIdx); trainIdxs.push_back(filteredMatches[i].trainIdx); } points1.clear(); points2.clear(); KeyPoint::convert(keypoints1, points1, queryIdxs); KeyPoint::convert(keypoints2, points2, trainIdxs); // cout << "point2size" << points2.size() << endl; //homography npoints1.clear();npoints2.clear(); Mpoints1.clear();Mpoints2.clear(); Mat H12, points1t; double ransacReprojThreshold = 10; if( ransacReprojThreshold >= 0 && points1.size() > 4) H12 = findHomography( Mat(points1), Mat(points2), CV_RANSAC, ransacReprojThreshold ); vector<char> matchesMask( filteredMatches.size(), 0 );// NONmatchesMask( filteredMatches.size(), 0 ); if( !H12.empty() ) { perspectiveTransform(Mat(points1), points1t, H12); double maxInlierDist = 10;//ransacReprojThreshold < 0 ? 3 : ransacReprojThreshold; for(i = 0; i < points1.size(); i++ ) { if( norm(points2[i] - points1t.at<Point2f>((int)i,0)) <= 5)// maxInlierDist ) // inlier { matchesMask[i] = 1; npoints2.push_back(points2[i]); npoints1.push_back(points1[i]); } } for(i=0; i<npoints2.size();i++) { for(j=0;j<MP1.size();j++) { double dist = norm(npoints2[i]-MP1[j]); // cout <<"dist \t" <<dist << endl; // waitKey(0); if(dist < 0.1) { Mpoints2.push_back(npoints2[i]); Mpoints1.push_back(npoints1[i]); break; } } } } Mat drawImg; drawMatches( img1ROI, keypoints1, img2ROI, keypoints2, filteredMatches, drawImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255), matchesMask #if DRAW_RICH_KEYPOINTS_MODE , DrawMatchesFlags::DRAW_RICH_KEYPOINTS #endif ); imshow( "correspondance", drawImg ); cout << "npoints1.size \t" << Mpoints1.size() << "\t" << Mpoints2.size() << endl; if(Mpoints1.size() > 8) weightScalingAspect(Mpoints1,Mpoints2,&scale); } } img1=img2; img1ROI = img2ROI; boxOrg =box; keypoints1 = keypoints2; descriptors1 =descriptors2; box.x += box.width/2; box.y += box.height/2; box.height = round(boxOrg.height *scale); box.width = round(( float(boxOrg.width)/float(boxOrg.height) ) * box.height); box.x -= box.width/2; box.y -= box.height/2; boundaryCheckRect(box); cout <<"SCALE \t" << scale << endl; gettimeofday(&t2, NULL); double diff = (float)((t2.tv_sec * 1000000 + t2.tv_usec) - (t1.tv_sec * 1000000 + t1.tv_usec)); diff = diff/1000; cout <<"Time taken in mili sec \t" << diff<< endl; // cout << tpdescriptors.rows << endl; //cout <<"BD \t" << bdescriptors.rows << endl; f1 << l << "\t" << FG_mp << "\t" << BG_mp << "\t" << FG << "\t"<< msI << "\n"; cout << "l \t" << l << "\t" <<" msI \t"<< msI << endl; imshow("img2",temp1); writer << temp1; waitKey(0); // boxOrg = eBox; char c = (char)waitKey(10); if( c == '\x1b' ) // esc { cout << "Exiting ..." << endl; break; } } trajectory.close(); return 0; }
void ObjectTester::TestObjectRanking(const DatasetName& dbname) { // load dataset FileInfos img_fns; FileInfos dmap_fns; map<string, vector<ImgWin>> rawgtwins; NYUDepth2DataMan nyudata; Berkeley3DDataManager berkeleydata; if(dbname == DB_NYU2_RGBD) { nyudata.GetImageList(img_fns); nyudata.GetDepthmapList(dmap_fns); if(img_fns.size() != dmap_fns.size()) return; nyudata.LoadGTWins(img_fns, rawgtwins); } if(dbname == DB_BERKELEY3D) { berkeleydata.GetImageList(img_fns); berkeleydata.GetDepthmapList(dmap_fns); if(img_fns.size() != dmap_fns.size()) return; berkeleydata.LoadGTWins(img_fns, rawgtwins); } GenericObjectDetector detector; if( !detector.InitBingObjectness() ) return; SalientRegionDetector saldet; SalientRGBDRegionDetector salrgbd; DepthSaliency depth_sal; vector<vector<ImgWin>> objdetwins(img_fns.size()), saldetwins(img_fns.size()), depthdetwins; vector<vector<ImgWin>> gtwins(img_fns.size()); #pragma omp parallel for for (int i=0; i<img_fns.size(); i++) { // read image Mat curimg = imread(img_fns[i].filepath); if(curimg.empty()) continue; // read depth Mat curdmap; if(dbname == DB_NYU2_RGBD) if( !nyudata.LoadDepthData(dmap_fns[i].filepath, curdmap) ) continue; if(dbname == DB_BERKELEY3D) if( !berkeleydata.LoadDepthData(dmap_fns[i].filepath, curdmap) ) continue; //#define VERBOSE #ifdef VERBOSE // show gt visualsearch::ImgVisualizer::DrawImgWins("gt", curimg, rawgtwins[img_fns[i].filename]); visualsearch::ImgVisualizer::DrawFloatImg("dmap", curdmap, Mat()); #endif // normalize to image //normalize(curdmap, curdmap, 0, 255, NORM_MINMAX); //curdmap.convertTo(curdmap, CV_8U); //cvtColor(curdmap, curdmap, CV_GRAY2BGR); //imshow("depthimg", curdmap); //waitKey(10); //visualsearch::ImgVisualizer::DrawImgWins("b3d", curimg, rawgtwins[img_fns[i].filename]); //waitKey(0); // resize Size newsz; //ToolFactory::compute_downsample_ratio(Size(curimg.cols, curimg.rows), 300, newsz); //resize(curimg, curimg, newsz); double start_t = getTickCount(); // get objectness windows vector<ImgWin> objboxes; detector.GetObjectsFromBing(curimg, objboxes, 1000); //visualsearch::ImgVisualizer::DrawImgWins("objectness", curimg, objboxes); cout<<"objectness: "<<(double)(getTickCount()-start_t) / getTickFrequency()<<endl; start_t = getTickCount(); // rank normalize(curdmap, curdmap, 0, 255, NORM_MINMAX); vector<ImgWin> salboxes = objboxes; int saltype = SAL_COLOR | SAL_DEPTH; salrgbd.Init(saltype, curimg, curdmap); salrgbd.RankWins(salboxes); //depth_sal.RankWins(curdmap, salboxes); cout<<"Depth ranking: "<<(double)(getTickCount()-start_t) / getTickFrequency()<<endl; #ifdef VERBOSE vector<Mat> imgs(50); for (int i=0; i<50; i++) { imgs[i] = curimg(salboxes[i]); } Mat dispimg; visualsearch::ImgVisualizer::DrawImgCollection("objectness", imgs, 50, 15, dispimg); imshow("objectness", dispimg); visualsearch::ImgVisualizer::DrawImgWins("saldet", curimg, salboxes); waitKey(0); #endif /*saldet.g_para.segThresholdK = 200; saldet.Init(curdmap); saldet.RankWins(salboxes);*/ //visualsearch::ImgVisualizer::DrawImgWins("sal", curimg, salboxes); //waitKey(0); // add to collection objdetwins[i] = objboxes; saldetwins[i] = salboxes; gtwins[i] = rawgtwins[img_fns[i].filename]; cout<<"Finish detection on "<<i<<"/"<<img_fns.size()<<endl; } // evaluation WindowEvaluator eval; vector<Point2f> objprvals, salprvals, depthprvals; int topnum[] = {1, 5, 10, 50, 100, 200, 500, 800, 1000}; for(int i=0; i<9; i++) { Point2f curpr = eval.ComputePR(objdetwins, gtwins, topnum[i]); objprvals.push_back(curpr); curpr = eval.ComputePR(saldetwins, gtwins, topnum[i]); salprvals.push_back(curpr); } // save to file ofstream out1("nyu_objpr.txt"); for (size_t i=0; i<objprvals.size(); i++) out1<<objprvals[i].x<<" "<<objprvals[i].y<<endl; ofstream out2("nyu_rgbdpr.txt"); for (size_t i=0; i<salprvals.size(); i++) out2<<salprvals[i].x<<" "<<salprvals[i].y<<endl; cout<<"Finish evaluation"<<endl; }
// Mean Shift Algorithm void meanShift(Mat& img1, Mat& img2, Ptr<DescriptorMatcher>& descriptorMatcher, int matcherFilterType, vector<KeyPoint>& tpkeypoints, Mat& tpdescriptors, vector<KeyPoint>& keypoints2, Mat& descriptors2, Mat& clusters1, Point2f &cp, int& flag, vector<Point2f>& MP1, Mat& img2ROI, vector<KeyPoint>& bkeypoints, Mat& bdescriptors, Mat& temp, int& FG_mp, int&FG, int& BG_mp, int& BG, int& FG_BG, int& msI) { size_t i,j; // Mat temp=img2.clone(); int converged = 0, semiConverged = 0; Mat img1ROI, labels1_; Point2f lastCenter(box.x+box.width/2,box.y+box.height/2); float scale = 1; img1ROI = img1(boxOrg); vector<Point2f> points1, bmp; KeyPoint::convert(tpkeypoints, points1); searchBin(tpdescriptors, clusters1, labels1_); // clustering based on Kmeans centers obatined earlier //vector<Point2f> np; // Mat newimg = img1ROI.clone(); // KeyPoint::convert(tpkeypoints, np); // for(size_t i=0;i<np.size();i++) // circle(newimg, np[i], 2, Scalar(255,0,255),2); // imshow( "msimg", newimg ); // np.clear(); // waitKey(0); vector<float> prevPDF(NOC); // pdf of source weightedPDF( points1, boxOrg, labels1_, NOC, prevPDF); // Making histogram/pdf by normalizing the data and applying weights based on positions // Iterations for finding the object Point2f zBCmax(0,0); // center corspndng to the iteration with max BC float BC, BCmax=0, BCprev=0, BCnow=0; // Bhattachrya coefficient, max val for an image, previous and current val for an iteration int stopCount=0; // MS iterations must converege for stopCount < ManualSetThreshold vector<Point2f> matchedPoints1, matchedPoints2; while ( !converged ) { // ofstream tempF; //tempF.open("tempF.txt", ios::out); matchedPoints1.clear(); matchedPoints2.clear(); Mat matchedDesc1, matchedDesc2; vector<int> queryIdxs, trainIdxs; cv::Rect expandedBox; #ifdef DEBUG cout << "iteration in while = \t" << ++iter << endl; #endif if (EXPANDED_BOX) { expandedBox = Rect(box.x-25, box.y-25, box.width+50, box.height+50); boundaryCheckRect(expandedBox); img2ROI = img2(expandedBox); } else { // cout << box.br() << "\t" << box.tl() << "\t" << img2.cols << endl; img2ROI = img2(box); } vector<KeyPoint> tempkey; // Mat pointsTransed21; MP1.clear(); doIteration(img1ROI, img2ROI, queryIdxs, trainIdxs,descriptorMatcher, matcherFilterType, tpkeypoints,tpdescriptors, keypoints2,descriptors2, matchedDesc1, matchedDesc2, matchedPoints1, matchedPoints2, MP1,tempkey); if(matchedPoints2.size() < 1) { FG=0; BG=0;FG_mp=0;BG_mp=0;FG_BG=0; msI=0; break; } // mdescriptors = matchedDesc2; // KeyPoint::convert(keypoints2, points2); if (EXPANDED_BOX) shiftPoints(matchedPoints2, expandedBox); else shiftPoints(matchedPoints2, box); // shiftPoints(matchedPoints1,boxOrg); vector<float> predPDF(NOC,0); Mat labels2, labels2_; // depending on PDF_OF_WHOLE Point2f z(0,0); //==================== Edited at 8th april =======================// bmp.clear(); Mat tmatchedDesc2, tmatchedDesc1; vector<Point2f> tmatchedPoints2; msI = stopCount; FG_mp = matchedPoints2.size(); vector<KeyPoint> tempbk; Mat tempBd; vector<DMatch> filteredMatches; crossCheckMatching( descriptorMatcher, bdescriptors, descriptors2, filteredMatches, 1 ); trainIdxs.clear(); queryIdxs.clear(); for( i = 0; i < filteredMatches.size(); i++ ) { queryIdxs.push_back(filteredMatches[i].queryIdx); trainIdxs.push_back(filteredMatches[i].trainIdx); } vector<Point2f> points1; KeyPoint::convert(bkeypoints, points1, queryIdxs); vector<Point2f> points2; KeyPoint::convert(keypoints2, points2, trainIdxs); vector<char> matchesMask( filteredMatches.size(), 0 ); ///// Mat H12; Mat drawImg; if (points2.size() < 4 ) { cout << "backpoints less than 4, hence prev ROI is retained" << endl; return; for(i=0;i<points2.size();i++) { bmp.push_back( points2[i]); tempBd.push_back(bdescriptors.row(queryIdxs[i])); tempbk.push_back(keypoints2[trainIdxs[i]]); tempBd.push_back(descriptors2.row(trainIdxs[i])); tempbk.push_back(keypoints2[trainIdxs[i]]); } } else { H12 = findHomography( Mat(points1), Mat(points2), CV_RANSAC, RANSAC_THREHOLD ); if( !H12.empty() ) { Mat points1t; perspectiveTransform(Mat(points1), points1t, H12); for( size_t i1 = 0; i1 < points1.size(); i1++ ) { double diff = norm(points2[i1] - points1t.at<Point2f>((int)i1,0)); if(diff <= 20) { matchesMask[i1]=1; bmp.push_back( points2[i1]); tempBd.push_back(bdescriptors.row(queryIdxs[i1])); tempbk.push_back(keypoints2[trainIdxs[i1]]); tempBd.push_back(descriptors2.row(trainIdxs[i1])); tempbk.push_back(keypoints2[trainIdxs[i1]]); } } drawMatches( img1ROI, bkeypoints, img2ROI, keypoints2, filteredMatches, drawImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255), matchesMask #if DRAW_RICH_KEYPOINTS_MODE , DrawMatchesFlags::DRAW_RICH_KEYPOINTS #endif ); } } imshow("bm",drawImg); //============edit part ==== shiftPoints(bmp, box); vector<int> bflag(bmp.size(),0); for(i=0;i<bmp.size();i++) bflag[i]=0; vector<int> ft(matchedPoints2.size(),0); for(i=0;i<matchedPoints2.size();i++) { ft[i]=0; for(j=0; j< bmp.size(); j++) { double diff = norm (matchedPoints2[i] - bmp[j]); // cout << diff << endl; if(diff < 0.5) { bflag[j]=1; ft[i]=1; break; } } if(ft[i]==0) { tmatchedPoints2.push_back(matchedPoints2[i]); tmatchedDesc1.push_back(matchedDesc1.row(i)); tmatchedDesc2.push_back(matchedDesc2.row(i)); } } //=================================================================// // allot descriptors to the clusters to make histogram searchBin(tmatchedDesc1, clusters1, labels1_); searchBin( tmatchedDesc2, clusters1, labels2); if (PDF_OF_WHOLE) searchBin( descriptors2, clusters1, labels2_); // find the PDF for the above histogram as per weights if (PDF_OF_WHOLE) weightedPDF( points2, box, labels2_, NOC, predPDF); else weightedPDF( tmatchedPoints2, box, labels2, NOC, predPDF); // find weights for each IPoint as per the values of weighted PDFs vector<float> weights(labels2.rows,0); Mat imgTemp = img2.clone(); findWeights( prevPDF, predPDF, labels1_, labels2, weights, queryIdxs, tmatchedDesc1, tmatchedDesc2); // find new ROI center as per above weights findNewCenter(tmatchedPoints2, weights, box, z); lastCenter = Point2f (box.x+box.width/2, box.y+box.height/2); // if current BC is less than previous BC, then take mean of the prev and current centers BCnow = findBC(predPDF,prevPDF); if (BCnow < BCprev) z = 0.5*(z+lastCenter); BCprev = BCnow; // check if ROI centers converge to same pixel if ( (norm(z - lastCenter) < 3)) { semiConverged = 1; if (!SHOW_FINAL_ROI) rectangle(temp, box, Scalar(0,0,255),2); } else { // keep iterating stopCount++; if (stopCount >= MAX_MS_ITER) { semiConverged = 1; flag = 0; if (!SHOW_FINAL_ROI) rectangle(temp, box, Scalar(0,0,255),2); z = zBCmax; } box.x = z.x - box.width/2; box.y = z.y - box.height/2; boundaryCheckRect(box); if (stopCount < MAX_MS_ITER) if (!SHOW_FINAL_ROI) ;// rectangle(temp, box, Scalar(0,255,0), 2); } // store values of max BC and corresponding center z if ( BCnow > BCmax) { BCmax = BC; zBCmax = z; } if (semiConverged) { converged = 1; // FG_mp, FG, BG_mp, BG, FG_BG, msI ; //==========edited on 5april ======== bdescriptors.release(); bkeypoints.clear(); for(i=0;i<tempBd.rows;i++) { bdescriptors.push_back(tempBd.row(i)); bkeypoints.push_back(tempbk[i]); } tpdescriptors.release(); tpkeypoints.clear(); //============================================// for(i=0;i<matchedPoints2.size();i++) { if(ft[i]==0) { tpdescriptors.push_back(matchedDesc1.row(i)); tpkeypoints.push_back(tempkey[i]); tpdescriptors.push_back(matchedDesc2.row(i)); tpkeypoints.push_back(tempkey[i]); } } //================================= box.x = z.x - box.width/2; box.y = z.y - box.height/2; // imgTemp.release(); trajectory << z.x << "\t" << z.y << "\t" << box.width << "\t" << box.height << endl; cp =z; cv::circle(temp, z, 3, Scalar(0,255,255), 3); cv::rectangle(temp, box, Scalar(255,0,0),2); cout << "MP1 \t" << MP1.size() <<"\t" << "bmp \t" <<bmp.size() << endl; for(size_t i=0;i<MP1.size();i++) {//circle(temp, MP1[i], 3, Scalar(255,255,255),3); circle(temp, matchedPoints2[i], 3, Scalar(255,0,255),3); } // shiftPoints(bmp,box); for(size_t i=0;i<bmp.size();i++) { circle(temp, bmp[i], 2, Scalar(0,0,0),2); // cout << bmp[i] << endl; } } char c = (char)waitKey(10); if( c == '\x1b' ) // esc { cout << "Exiting from while iterator..." << endl; break; } } cv::imshow("Iter", temp); // waitKey(0); eachIter.close(); }
void MatDagMat(float *out, float **gauge, float *in, float kappa) { float *tmp = (float*)malloc(N*spinorSiteSize*sizeof(float)); Mat(tmp, gauge, in, kappa); MatDag(out, gauge, tmp, kappa); free(tmp); }
sktinfoextractor::sktinfoextractor(cameras* c,vector<Mat> mix, vector<camconfig*> configs,calibrationskt* cal,tuiomousewrapper* tm,string hst,int prt,bool autostart,QWidget *parent) : QDialog(parent), ui(new Ui::sktinfoextractor) { ui->setupUi(this); cam=c; cConfig=configs; calMat=mix[0]; mD=ui->doubleSpinBox->value(); isDCCreated=false; useDC=false; instance=this; for(int i=0; i<cam->numContextosIniciados; i++) { Mat im,dep,msk,mix,depC(480,640,CV_8UC3),depT,pC,depS(480,640,CV_32FC1); imgs.push_back(im); depths.push_back(dep); masks.push_back(msk); mixs.push_back(mix); depthsC.push_back(depC); depthsT.push_back(depT); pCs.push_back(pC); depthsS.push_back(depS); sktprocessor* sP=new sktprocessor(); sP->cConfig=cConfig[i]; sktP.push_back(sP); toBlobs.push_back(Mat(480,640,CV_8UC1)); vector<Point2f> fB; vector<int> bS; finBlobs.push_back(fB); blobSizes.push_back(bS); } real=new XnPoint3D[1000]; proj=new XnPoint3D[1000]; is2CamCalib=false; if(calMat.cols>2){ matC[0][0]=calMat.at<double>(0,0); matC[0][1]=calMat.at<double>(0,1); matC[0][2]=calMat.at<double>(0,2); matC[0][3]=calMat.at<double>(0,3); matC[1][0]=calMat.at<double>(1,0); matC[1][1]=calMat.at<double>(1,1); matC[1][2]=calMat.at<double>(1,2); matC[1][3]=calMat.at<double>(1,3); matC[2][0]=calMat.at<double>(2,0); matC[2][1]=calMat.at<double>(2,1); matC[2][2]=calMat.at<double>(2,2); matC[2][3]=calMat.at<double>(2,3); is2CamCalib=true; } sendTuio=false; isServerCreated=false; calSKT=cal; if(cam->numContextosIniciados<2){ ui->twoCamsMenu->setDisabled(true); } ui->mixActive->setChecked(is2CamCalib); ui->mixActive->setDisabled(!is2CamCalib); //inicio=clock(); numFrames=0; tmw=tm; minDataUpdate=0.0; ui->numThreadsText->setText(QString::number(omp_get_max_threads())); isProcessing=true; this->setWindowIcon(QIcon(":/imagenes/isotipo.png")); if(autostart){ ui->tuioHost->setText(QString::fromStdString(hst)); ui->tuioPort->setValue(prt); ui->sendTuioCheck->toggle(); } timer=new QTimer(this); timer->start(20); QObject::connect(timer, SIGNAL(timeout()), this, SLOT(hacerUpdate())); }
inline Mat CudaMem::createMatHeader() const { return Mat(size(), type(), data, step); }
void MeanShiftDemo( VideoCapture& video, Rect& starting_position, int starting_frame_number, int end_frame) { bool half_size = true; video.set(CV_CAP_PROP_POS_FRAMES,starting_frame_number); Mat current_frame, hls_image; std::vector<cv::Mat> hls_planes(3); video >> current_frame; Rect current_position(starting_position); if (half_size) { resize(current_frame, current_frame, Size( current_frame.cols/2, current_frame.rows/2 )); current_position.height /= 2; current_position.width /= 2; current_position.x /= 2; current_position.y /= 2; } cvtColor(current_frame, hls_image, CV_BGR2HLS); split(hls_image,hls_planes); int chosen_channel = 0; // Hue channel Mat image1ROI = hls_planes[chosen_channel](current_position); float channel_range[2] = { 0.0, 255.0 }; int channel_numbers[1] = { 0 }; int number_bins[1] = { 32 }; MatND histogram[1]; const float* channel_ranges = channel_range; calcHist(&(image1ROI), 1, channel_numbers, Mat(), histogram[0], 1 , number_bins, &channel_ranges); normalize(histogram[0],histogram[0],1.0); rectangle(current_frame,current_position,Scalar(0,255,0),2); Mat starting_frame = current_frame.clone(); int frame_number = starting_frame_number; while (!current_frame.empty() && (frame_number < end_frame)) { // Calculate back projection Mat back_projection_probabilities; calcBackProject(&(hls_planes[chosen_channel]),1,channel_numbers,*histogram,back_projection_probabilities,&channel_ranges,255.0); // Remove low saturation points from consideration Mat saturation_mask; inRange( hls_image, Scalar(0,10,50,0),Scalar(180,256,256,0), saturation_mask ); bitwise_and( back_projection_probabilities, back_projection_probabilities,back_projection_probabilities, saturation_mask ); // Mean shift TermCriteria criteria(cv::TermCriteria::MAX_ITER,5,0.01); meanShift(back_projection_probabilities,current_position,criteria); // Output to screen rectangle(current_frame,current_position,Scalar(0,255,0),2); Mat chosen_channel_image, back_projection_image; cvtColor(hls_planes[chosen_channel], chosen_channel_image, CV_GRAY2BGR); cvtColor(back_projection_probabilities, back_projection_image, CV_GRAY2BGR); Mat row1_output = JoinImagesHorizontally( starting_frame, "Starting position", chosen_channel_image, "Chosen channel (Hue)", 4 ); Mat row2_output = JoinImagesHorizontally( back_projection_image, "Back projection", current_frame, "Current position", 4 ); Mat mean_shift_output = JoinImagesVertically(row1_output,"",row2_output,"", 4); imshow("Mean Shift Tracking", mean_shift_output ); // Advance to next frame video >> current_frame; if (half_size) resize(current_frame, current_frame, Size( current_frame.cols/2, current_frame.rows/2 )); cvtColor(current_frame, hls_image, CV_BGR2HLS); split(hls_image,hls_planes); frame_number++; cvWaitKey(1000); } char c = cvWaitKey(); cvDestroyAllWindows(); }
//! 字符分割与排序 int CCharsSegment::charsSegment(Mat input, vector<Mat>& resultVec) { if (!input.data) return 0x01; int w = input.cols; int h = input.rows; Mat tmpMat = input(Rect_<double>(w * 0.1, h * 0.1, w * 0.8, h * 0.8)); // 判断车牌颜色以此确认threshold方法 Color plateType = getPlateType(tmpMat, true); Mat input_grey; cvtColor(input, input_grey, CV_BGR2GRAY); Mat img_threshold; // 二值化 // 根据车牌的不同颜色使用不同的阈值判断方法 // TODO:使用MSER来提取这些轮廓 if (BLUE == plateType) { // cout << "BLUE" << endl; img_threshold = input_grey.clone(); int w = input_grey.cols; int h = input_grey.rows; Mat tmp = input_grey(Rect_<double>(w * 0.1, h * 0.1, w * 0.8, h * 0.8)); int threadHoldV = ThresholdOtsu(tmp); // utils::imwrite("E:/img_inputgray2.jpg", input_grey); threshold(input_grey, img_threshold, threadHoldV, 255, CV_THRESH_BINARY); // utils::imwrite("E:/img_threshold.jpg", img_threshold); // threshold(input_grey, img_threshold, 5, 255, CV_THRESH_OTSU + // CV_THRESH_BINARY); } else if (YELLOW == plateType) { // cout << "YELLOW" << endl; img_threshold = input_grey.clone(); int w = input_grey.cols; int h = input_grey.rows; Mat tmp = input_grey(Rect_<double>(w * 0.1, h * 0.1, w * 0.8, h * 0.8)); int threadHoldV = ThresholdOtsu(tmp); utils::imwrite("resources/image/tmp/inputgray2.jpg", input_grey); threshold(input_grey, img_threshold, threadHoldV, 255, CV_THRESH_BINARY_INV); // threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU + // CV_THRESH_BINARY_INV); } else if (WHITE == plateType) { // cout << "WHITE" << endl; /*img_threshold = input_grey.clone(); int w = input_grey.cols; int h = input_grey.rows; Mat tmp = input_grey(Rect(w*0.1, h*0.1, w*0.8, h*0.8)); int threadHoldV = ThresholdOtsu(tmp); utils::imwrite("resources/image/tmp/inputgray2.jpg", input_grey);*/ threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU + CV_THRESH_BINARY_INV); } else { // cout << "UNKNOWN" << endl; threshold(input_grey, img_threshold, 10, 255, CV_THRESH_OTSU + CV_THRESH_BINARY); } if (0) { imshow("threshold", img_threshold); waitKey(0); destroyWindow("threshold"); } if (m_debug) { stringstream ss(stringstream::in | stringstream::out); ss << "resources/image/tmp/debug_char_threshold" << iTag << ".jpg"; utils::imwrite(ss.str(), img_threshold); } // 去除车牌上方的柳钉以及下方的横线等干扰 // 并且也判断了是否是车牌 // 并且在此对字符的跳变次数以及字符颜色所占的比重做了是否是车牌的判别条件 // 如果不是车牌,返回ErrorCode=0x02 if (!clearLiuDing(img_threshold)) return 0x02; if (m_debug) { stringstream ss(stringstream::in | stringstream::out); ss << "resources/image/tmp/debug_char_clearLiuDing" << iTag << ".jpg"; utils::imwrite(ss.str(), img_threshold); } iTag++; // 在二值化图像中提取轮廓 Mat img_contours; img_threshold.copyTo(img_contours); vector<vector<Point> > contours; findContours(img_contours, contours, // a vector of contours CV_RETR_EXTERNAL, // retrieve the external contours CV_CHAIN_APPROX_NONE); // all pixels of each contours vector<vector<Point> >::iterator itc = contours.begin(); vector<Rect> vecRect; // 将不符合特定尺寸的字符块排除出去 while (itc != contours.end()) { Rect mr = boundingRect(Mat(*itc)); Mat auxRoi(img_threshold, mr); if (verifyCharSizes(auxRoi)) vecRect.push_back(mr); ++itc; } // 如果找不到任何字符块,则返回ErrorCode=0x03 if (vecRect.size() == 0) return 0x03; // 对符合尺寸的图块按照从左到右进行排序; // 直接使用stl的sort方法,更有效率 vector<Rect> sortedRect(vecRect); std::sort(sortedRect.begin(), sortedRect.end(),[](const Rect& r1, const Rect& r2) { return r1.x < r2.x; }); size_t specIndex = 0; //获得特殊字符对应的Rectt,如苏A的"A" specIndex = GetSpecificRect(sortedRect); if (m_debug) { if (specIndex < sortedRect.size()) { Mat specMat(img_threshold, sortedRect[specIndex]); stringstream ss(stringstream::in | stringstream::out); ss << "resources/image/tmp/debug_specMat" << ".jpg"; utils::imwrite(ss.str(), specMat); } } //根据特定Rect向左反推出中文字符 //这样做的主要原因是根据findContours方法很难捕捉到中文字符的准确Rect,因此仅能 //退过特定算法来指定 Rect chineseRect; if (specIndex < sortedRect.size()) chineseRect = GetChineseRect(sortedRect[specIndex]); else return -3; if (m_debug) { Mat chineseMat(img_threshold, chineseRect); stringstream ss(stringstream::in | stringstream::out); ss << "resources/image/tmp/debug_chineseMat" << ".jpg"; utils::imwrite(ss.str(), chineseMat); } //新建一个全新的排序Rect //将中文字符Rect第一个加进来,因为它肯定是最左边的 //其余的Rect只按照顺序去6个,车牌只可能是7个字符!这样可以避免阴影导致的“1”字符 vector<Rect> newSortedRect; newSortedRect.push_back(chineseRect); RebuildRect(sortedRect, newSortedRect, specIndex); if (newSortedRect.size() == 0) return -3; for (size_t i = 0; i < newSortedRect.size(); i++) { Rect mr = newSortedRect[i]; Mat auxRoi(img_threshold, mr); if (1) { auxRoi = preprocessChar(auxRoi); if (m_debug) { stringstream ss(stringstream::in | stringstream::out); ss << "resources/image/tmp/debug_char_auxRoi_" << (i + staticIndex) << ".jpg"; utils::imwrite(ss.str(), auxRoi); } resultVec.push_back(auxRoi); } } staticIndex += newSortedRect.size(); return 0; }
void Calibration::updateUndistortion() { Mat undistortedCameraMatrix = getOptimalNewCameraMatrix(distortedIntrinsics.getCameraMatrix(), distCoeffs, distortedIntrinsics.getImageSize(), fillFrame ? 0 : 1); initUndistortRectifyMap(distortedIntrinsics.getCameraMatrix(), distCoeffs, Mat(), undistortedCameraMatrix, distortedIntrinsics.getImageSize(), CV_16SC2, undistortMapX, undistortMapY); undistortedIntrinsics.setup(undistortedCameraMatrix, distortedIntrinsics.getImageSize()); }
void pxsnsr(vector<vector<Point>> &contours, Mat &Seg_img_red, Mat &Seg_img_blue) { Rect *r = new Rect[contours.size()]; // 定义外接矩形数组 Mat obj_rec_thr = Mat::zeros(Seg_img_red.size(), CV_8UC3); for (unsigned int i = 0; i < contours.size(); i++) { r[i] = boundingRect(Mat(contours[i]));// boundingRect获取这个外接矩形 } /// 绘出轮廓及其凸包 Mat Seg_img_blue_hull(Seg_img_blue.size(), CV_8U, Scalar(0)); vector<vector<Point> >hull(contours.size()); for (unsigned int i = 0; i< contours.size(); i++) { convexHull(Mat(contours[i]), hull[i], false); fillConvexPoly(Seg_img_blue_hull, &hull[i][0], hull[i].size(), Scalar(1)); } erode(Seg_img_blue_hull, Seg_img_blue_hull, Mat(), Point(-1, -1), dilate_size); // 对图像进行之前的膨胀恢复 Seg_img_blue_hull.convertTo(Seg_img_blue_hull, CV_32F); imshow("Seg_img_blue _hull", Seg_img_blue_hull); double Evaluation = 0; // 对潜在目标的打分值初始化 double Evaluation_max = 0; // 对潜在目标的打分最大值初始化 int index_best = -1; // 最优轮廓标记 <注意此处初始值应为-1> int index = 0; // 轮廓标记 cout << contours.size() << endl; vector<vector<Point>>::const_iterator itContours = contours.begin(); //for (; itContours != contours.end(); ++itContours) while (itContours != contours.end()) { Mat imageROI_red = Seg_img_red(cv::Rect(r[index].x, r[index].y, r[index].width, r[index].height)); Mat imageROI_blue = Seg_img_blue_hull(cv::Rect(r[index].x, r[index].y, r[index].width, r[index].height)); Mat imageROI_red_blue = imageROI_red + imageROI_blue; threshold(imageROI_red_blue, imageROI_red_blue, 1, 1, THRESH_BINARY); // 进行阈值分割(大于阈值1等于2时候取 1) Scalar s1 = sum(imageROI_red_blue); Scalar s2 = sum(imageROI_blue); double sum_red = s1.val[0]; // 获取图像块包含在蓝色中的红色像素数量 double sum_blue = s2.val[0]; // 获取图像块中蓝色像素数量 double pixel_sum_rate = rate(sum_red, sum_blue); // 计算图像块中红蓝像素的比例 cout << "sum_red:" << sum_red << "\t" << "," << "sum_blue:" << sum_blue << "\t"; cout << "pixel_sum_rate:" << pixel_sum_rate << endl; // 将红蓝像素比太低的连通域轮廓删除 if ((pixel_sum_rate < threshold_value_pixel_rate) || (sum_red < 12)) // 如当前轮廓不含一定的红色像素 { itContours = contours.erase(itContours); // 删除当前轮廓 <特别注意:删除当前轮廓后迭代器自动指向后一个> index++; continue; } else // 如当前轮廓含一定的红色像素 { int aaa = contours.size(); // 用于设置条件断点 Evaluation = sum_red; // 目标轮廓简单评价值定义 if (Evaluation > Evaluation_max) { Evaluation_max = Evaluation; index_best++; cout << "index_best - " << index_best << endl; } index++; itContours++; // 继续检索下一个轮廓 <此处必须要代码指定迭代器转向后一个轮廓> } } int ttt = contours.size(); // 用于设置条件断点 // 如果仍然有大于一个潜在目标则选取最优的一个 if (ttt > 1) { int index = 0; vector<vector<Point>>::const_iterator itContours_2 = contours.begin(); while(itContours_2 != contours.end()) { if (index != index_best) itContours_2 = contours.erase(itContours_2); else ++itContours_2; index++; } } delete[] r; }
void UMatToVector(const UMat & um, std::vector<Point2f> & v) const { v.resize(um.size().area()); um.copyTo(Mat(um.size(), CV_32FC2, &v[0])); }
vector<Rect> visionUtils::segmentLineBoxFit(Mat img0, int minPixelSize, int maxSegments, Mat *returnMask, std::vector<std::vector<cv::Point> > *returnContours, vector<RotatedRect> *rotatedBoundingBox, bool displayFaces) { // Segments items in gray image (img0) // minPixelSize= pixels, threshold for removing smaller regions, with less than minPixelSize pixels // 0, returns all detected segments // maxSegments = max no segments to return, 0 = all RNG rng(12345); int padPixels=15; // Rect border added at start... Rect tempRect; tempRect.x=padPixels; tempRect.y=padPixels; tempRect.width=img0.cols; tempRect.height=img0.rows; Mat img1 = Mat::zeros(img0.rows+(padPixels*2), img0.cols+(padPixels*2), CV_8UC1); img0.copyTo(img1(tempRect)); // find the contours std::vector<std::vector<cv::Point> > contours; vector<Vec4i> hierarchy; findContours(img1, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); // Mask for segmented region Mat mask = Mat::zeros(img1.rows, img1.cols, CV_8UC3); vector<double> areas(contours.size()); // Case for using minimum pixel size Vec4f lines; Scalar color; // sort contours std::sort(contours.begin(), contours.end(), compareContourAreas); // grab contours vector<Rect> boundingBox; // LB testing vector<RotatedRect> tempRotatedBoundingBox; std::vector<std::vector<cv::Point> > tempReturnContours; int maxIterations = 0; if( contours.size() > 0 ) { if (maxSegments==0)// return all contours.. maxIterations = contours.size(); else if((int)contours.size() >= maxSegments) maxIterations = maxSegments; else maxIterations = 1; // LB: need to check this is correct! int contourCount=0; for (int j = 1; j < maxIterations+1; j++) { int i = contours.size()-j; if (contourArea(Mat(contours[i]))>minPixelSize) { // Fit rotated rect to contour tempRotatedBoundingBox.push_back(minAreaRect( Mat(contours[i]) )); Point2f rectCentre=tempRotatedBoundingBox[contourCount].center; rectCentre.x=rectCentre.x-padPixels; rectCentre.y=rectCentre.y-padPixels; tempRotatedBoundingBox[contourCount].center=rectCentre; // Find line limits.... boundingBox.push_back(boundingRect(Mat(contours[i]))); // Remove edge padding effects.... boundingBox[contourCount].x=boundingBox[contourCount].x-padPixels; boundingBox[contourCount].y=boundingBox[contourCount].y-padPixels; boundingBox[contourCount]=checkRoiInImage(img0, boundingBox[contourCount]); contourCount++; tempReturnContours.push_back(contours[i]); } } // Return contours returnContours->resize(tempReturnContours.size()); *returnContours = tempReturnContours; // Return rotated rects rotatedBoundingBox->resize(tempRotatedBoundingBox.size()); *rotatedBoundingBox = tempRotatedBoundingBox; // normalize so imwrite(...)/imshow(...) shows the mask correctly! cv::normalize(mask.clone(), mask, 0.0, 255.0, CV_MINMAX, CV_8UC1); // To Remove border added at start... *returnMask=mask(tempRect); // show the images if (displayFaces) imshow("Seg line utils: Img in", img0); if (displayFaces) imshow("Seg line utils: Mask", *returnMask); if (displayFaces) imshow("Seg line utils: Output", img1); } return boundingBox; }
bool CHMM::loadConf(Config &cfg,char *model_str) { const Setting& root = cfg.getRoot(); Setting &hmm = root["HMM"]; Setting &_nclasses=hmm["nclasses"]; Setting &_models=hmm["models"]; int ndim=(int)hmm["ndim"]; Setting &model=hmm[(const char *)model_str]; int nstates=model["nstates"]; int ncomponents=model["ncomponents"]; float lthresh=model["lthresh"]; //lthresh=lthresh; Mat _transition=Mat(nstates,nstates,CV_32FC1); Mat _initial=Mat(1,nstates,CV_32FC1); vector<GaussianMixture> gauss; gauss.resize(nstates); Setting &transition = model["transition"]; for(int j=0;j<transition.getLength();j++) { _transition.at<float>(j)=(float)transition[j]; } Setting &initial = model["initial"]; for(int j=0;j<initial.getLength();j++) { _initial.at<float>(j)=(float)initial[j]; } for(int j=0;j<nstates;j++) { char str[100]; sprintf(str,"emission%d",j); Setting &emission = model[(const char *)str]; GaussianMixture g=gauss[j]; g.setnmix(ncomponents); for(int k=0;k<ncomponents;k++) { Gaussian g1; sprintf(str,"gmm%d",k); Setting &mix=emission[(const char *)str]; Setting &mean=mix["mean"]; Mat _mean=Mat(1,ndim,CV_32FC1); //_mean.resize(ndim); for(int l=0;l<ndim;l++) { _mean.at<float>(l)=(float)mean[l]; } g1.setMean(_mean); Setting &covar=mix["covar"]; Mat _covar=Mat(ndim,ndim,CV_32FC1); int cc=0; for(int l=0;l<ndim;l++) { for(int m=0;m<ndim;m++) { _covar.at<float>(l,m)=(float)covar[cc]; cc++; } } g1.setSigma(_covar); float weight=(float)mix["weight"]; g.setGaussian(g1,weight); } gauss[j]=g; } this->setData(_transition,_initial,gauss,lthresh); }
Mat visionUtils::cannySegmentation(Mat img0, int minPixelSize, bool displayFaces) { // Segments items in gray image (img0) // minPixelSize= // -1, returns largest region only // pixels, threshold for removing smaller regions, with less than minPixelSize pixels // 0, returns all detected segments // LB: Zero pad image to remove edge effects when getting regions.... int padPixels=20; // Rect border added at start... Rect tempRect; tempRect.x=padPixels; tempRect.y=padPixels; tempRect.width=img0.cols; tempRect.height=img0.rows; Mat img1 = Mat::zeros(img0.rows+(padPixels*2), img0.cols+(padPixels*2), CV_8UC1); img0.copyTo(img1(tempRect)); if (useGPU)// converted to GPU -> NOT tested to speed up here! { GpuMat imgGPU; imgGPU.upload(img1); #if CV_MAJOR_VERSION == 2 gpu::Canny(imgGPU, imgGPU, 100, 200, 3); //100, 200, 3); #elif CV_MAJOR_VERSION == 3 cv::Ptr<cv::cuda::CannyEdgeDetector> canny = cv::cuda::createCannyEdgeDetector(100, 200, 3); canny->detect(imgGPU, imgGPU); #endif imgGPU.download(img1); } else { Canny(img1, img1, 100, 200, 3); //100, 200, 3); } // find the contours vector< vector<Point> > contours; findContours(img1, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); // Mask for segmented regiond Mat mask = Mat::zeros(img1.rows, img1.cols, CV_8UC1); vector<double> areas(contours.size()); if (minPixelSize==-1) { // Case of taking largest region for(int i = 0; i < (int)contours.size(); i++) areas[i] = contourArea(Mat(contours[i])); double max; Point maxPosition; cv::minMaxLoc(Mat(areas),0,&max,0,&maxPosition); drawContours(mask, contours, maxPosition.y, Scalar(1), CV_FILLED); } else { // Case for using minimum pixel size for (int i = 0; i < (int)contours.size(); i++) { if (contourArea(Mat(contours[i]))>minPixelSize) drawContours(mask, contours, i, Scalar(1), CV_FILLED); } } // normalize so imwrite(...)/imshow(...) shows the mask correctly! cv::normalize(mask.clone(), mask, 0.0, 255.0, CV_MINMAX, CV_8UC1); Mat returnMask; returnMask=mask(tempRect); // show the images if (displayFaces) imshow("Canny: Img in", img0); if (displayFaces) imshow("Canny: Mask", returnMask); if (displayFaces) imshow("Canny: Output", img1); return returnMask; }
void VirtualSurgeon_Warp::face_warp(vector<Mat* >& imgs, vector<Point2d>& points1, vector<Point2d>& points2, Size im2_size, face_warp_method method, double alpha) { //Move points to align one on top of the other Scalar m1 = mean(Mat(points1)); Mat p2M(points2); Scalar m2 = mean(p2M); p2M = p2M - m2 + m1; vector<Point2d> restorePts2 = points2; //anchor first and last points Point2d tmpPts[2] = {points2[0],points2[points2.size()-1]}; //save for restore points2[0] = points1[0]; points2[points2.size()-1] = points1[points1.size()-1]; //use alpha to interpolate between points sets Mat p1M(points1); //Mat p2M(points2); p2M = p2M * alpha + p1M * (1 - alpha); Mat& tmpIm = *(imgs[0]); //put 4 anchors in corners of image for rigidity of deformation Point2d pts[4] = {Point2d(1,1),Point2d(1,tmpIm.rows-2),Point2d(tmpIm.cols-2,tmpIm.rows-2),Point2d(tmpIm.cols-2,1)}; for(int i=0;i<4;i++) { points1.push_back(pts[i]); points2.push_back(pts[i]); } bool computed = false; vector<Point2d> mesh; for(unsigned int imIdx = 0;imIdx<imgs.size();imIdx++) { Mat& im1 = *(imgs[imIdx]); if(!p.no_gui) { Mat clone; clone.create(im1.size(),im1.type()); im1.copyTo(clone); for(unsigned int i=0;i<points1.size();i++) { circle(clone,points1[i],2,Scalar(0,0,255),CV_FILLED); circle(clone,points2[i],2,Scalar(0,255,255),CV_FILLED); line(clone,points1[i],points2[i],Scalar(255,0,0),2); } imshow("tmp",clone); int c = waitKey(p.wait_time); } if(!computed) { mesh = vector<Point2d>(im1.rows*im1.cols,Point2d(0,0)); for(int y=0;y<im1.rows;y++) { for(int x=0;x<im1.cols;x++) { mesh[y*im1.cols + x] = Point2d(x,y); } } if(!p.no_gui) { printf("Precompute weights...\n"); } if(method == FACE_WARP_AFFINE) { Affine_Precompute(points2,mesh); // } else { // Rigid_Precompute(points2,mesh); // } // //#ifdef BTM_DEBUG // printf("Warp mesh...\n"); //#endif // if(method == FACE_WARP_AFFINE) { Affine_doWarp(points1,mesh); // } else { // Rigid_doWarp(points2,points1,mesh); // Rigid_release(); } else { Rigid_doAll(points2,points1,mesh); } computed = true; } Mat warped(im1.size(),im1.type()); int warpedCn = warped.channels(); int im1Cn = im1.channels(); for(int y=0;y<im1.rows;y++) { uchar* warpedRowPtr = warped.ptr<uchar>(y); for(int x=0;x<im1.cols;x++) { uchar* pxlP = warpedRowPtr + x * warpedCn; Point2d meshP = mesh[y*im1.cols + x]; int xMsh = max(min((int)floor(meshP.x),im1.cols-1),0); int yMsh = max(min((int)floor(meshP.y),im1.rows-1),0); uchar* origP = im1.data + yMsh * im1.step + xMsh * im1Cn; for(int cn=0;cn<warpedCn;cn++) { pxlP[cn] = origP[cn]; } } } if(!p.no_gui) { //namedWindow("warped"); Mat _tmp; warped.copyTo(_tmp); for(unsigned int i=0;i<points2.size();i++) circle(_tmp,points2[i],2,Scalar(0,0,255),CV_FILLED); imshow("tmp",_tmp); waitKey(p.wait_time); } warped.copyTo(im1); } for(int i=0;i<4;i++) {points1.pop_back();points2.pop_back();} //points2[0] = tmpPts[0]; //points2[points2.size()-1] = tmpPts[1]; points2 = restorePts2; p2M = Mat(points2); p2M = p2M - m1 + m2; //restore original position of points }
Mat visionUtils::segmentFace(Mat srcImage, Mat maskImage, bool displayFaces, Mat *skinSegMaskInv) { // Check mask and original image are the same size Size srcS = srcImage.size(); int heightS = srcS.height; int widthS = srcS.width; Size maskS = maskImage.size(); int heightM = maskS.height; int widthM = maskS.width; if (heightS!=heightM || widthS!=widthM) { cout << "hS:" << heightS << " wS:" << widthS << " hM:" << heightM << " wM" << widthM << endl; cout << "Source and mask images are not the same size... aborting" << endl; Mat ttt; return (ttt); } /// Convert image to gray and blur it cv::cvtColor( maskImage, src_gray, CV_BGR2GRAY ); cv::blur( src_gray, src_gray, Size(3,3) ); vector<vector<Point> > contours; vector<Vec4i> hierarchy; /// Detect edges using Threshold /// Find contours findContours( src_gray, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); // ########## Remove contour indents (defects), by finding the convex /// Find the convex hull object for each contour vector<vector<Point> >hull( contours.size() ); for( int i = 0; i < (int)contours.size(); i++ ) { convexHull( Mat(contours[i]), hull[i], false ); } /// Draw contours + hull results Mat drawingHull = Mat::zeros( src_gray.size(), CV_8UC3 ); //Check minimum contour size and find largest.... int largest_area=-1; int largest_contour_index=0; for( int i = 0; i< (int)contours.size(); i++ ) { if( (int)contours[i].size() > minContourSize ) { double a=contourArea( contours[i],false); // Find the area of contour if(a>largest_area) { largest_area=a; largest_contour_index=i; } } } if (displayFaces) { RNG rng(12345); // for colour generation for( int i = 0; i< (int)contours.size(); i++ ) { Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); drawContours( drawingHull, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); drawContours( drawingHull, hull, i, color, 1, 8, vector<Vec4i>(), 0, Point() ); } imshow( "Contour Convex Hull", drawingHull ); } //// ############### Selected Hull contour to use -> ignoring ellipse etc // Check if hull found successfully... if not ABORT if (hull.empty() ) { cout << "Hull region not found > returning...." << endl; Mat ttt; return (ttt); } // Check area of hull and abort if neded vector<Point> approx; approxPolyDP(hull[largest_contour_index], approx, 5, true); double area1 = contourArea(approx); if (area1<4000) { cout << "Hull area too small > returning...." << endl; Mat ttt; return (ttt); } // Cut down rect around convex contour hull Rect boundRect; boundRect=boundingRect(Mat(hull[largest_contour_index])); // Check bounding box fits inside image.... resize if needed boundRect=checkRoiInImage(srcImage, boundRect); // Check bounding box has greater dimensions than 5x5pix if (boundRect.height<=5 || boundRect.width<=5) { cout << "Region selected too small... exiting" << endl; Mat ttt; return (ttt); } else { /// Repeat boxing but for masked skin data (Hull) // Make binary mask using hull largest contour Mat srcSegSkin = Mat::zeros( srcImage.size(), CV_8UC3 ); Mat skinSegMask = Mat::zeros( srcImage.size(), CV_8UC1 ); drawContours( skinSegMask, hull, largest_contour_index, Scalar(255), -1, 8, vector<Vec4i>(), 0, Point() ); srcImage.copyTo(srcSegSkin,skinSegMask); // Copy using mask from skinSegMask srcSegSkin=srcSegSkin(boundRect); // Make face blocking mask (face pix = 0) Mat skinSegMaskInvTemp = Mat::zeros( srcImage.size(), CV_8UC1 ); cv::bitwise_not(skinSegMaskInvTemp,*skinSegMaskInv,skinSegMask); if (displayFaces) { // Take boxed region of face from original image data // Copy inital image and section with bounding box Mat srcSegmented = srcImage.clone(); srcSegmented=srcSegmented(boundRect); imshow("Rect region orig",srcSegmented); Mat maskSegmented = maskImage.clone(); maskSegmented=maskSegmented(boundRect); imshow("Rect region, with SkinSeg",maskSegmented); imshow("Rect region, with hull region SkinSeg",srcSegSkin); } return(srcSegSkin); } }
/** * Run hierarchical k-means with a distance threshold of 0.15 meters */ Mat TableObjectDetector::clusterObjectsHierarchical(cv::Mat P, int max_clusters) { Mat L = Mat::zeros (P.rows, 1, CV_32S); double dthresh = 0.15; int currentClusterNum = 0; int num_iter = 30; std::stack<Cluster*> c_stack; // Initialize with a single cluster containing all datapoints Cluster* C = new Cluster(); Mat D = Mat(P.rows, 4, CV_64F); P.copyTo(D.colRange(0, 3)); // ID each point so we return them in the same order for (int i=0; i<D.rows; i++) { D.at<double>(i, 3) = i; } C->setData(D); c_stack.push(C); // Run hierarchical k-means for (int t=0; t<num_iter; t++) { if (currentClusterNum == max_clusters) { return L; } if (c_stack.empty()) { return L; } Cluster* C = (Cluster*)c_stack.top(); c_stack.pop(); Mat D = C->getData(); // Calculate cluster centroid Mat Cmean; reduce(D, Cmean, 0, CV_REDUCE_AVG); // Calculate max distance double maxDist = 0; for (int i=0; i<D.rows; i++) { double dx = D.at<double>(i, 0) - Cmean.at<double>(0); double dy = D.at<double>(i, 1) - Cmean.at<double>(1); double dz = D.at<double>(i, 2) - Cmean.at<double>(2); double dist = sqrt(dx*dx + dy*dy + dz*dz); if (dist > maxDist) { maxDist = dist; } } // Check to see if this cluster satisfies the conditions if (maxDist < dthresh) { for (int i=0; i<D.rows; i++) { int idx = (int)D.at<double>(i, 3); L.at<int>(idx) = currentClusterNum; } currentClusterNum++; } else { Mat L_iter; int attempts = 5; Mat D32 = Mat(D.rows, 3, CV_64F); D.colRange(0, 3).copyTo(D32); D32.convertTo(D32, CV_32F); kmeans(D32, 2, L_iter, TermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 10000, 0.0001), attempts, KMEANS_PP_CENTERS); Mat D0 = Mat(0, 3, CV_64F); Mat D1 = Mat(0, 3, CV_64F); for (int i=0; i<L_iter.rows; i++) { if (L_iter.at<int>(i) == 0) { D0.push_back(D.row(i)); } else { D1.push_back(D.row(i)); } } Cluster* C0 = new Cluster(); C0->setData(D0); Cluster* C1 = new Cluster(); C1->setData(D1); c_stack.push(C0); c_stack.push(C1); } } return L; }
Mat& CHandGestureRecognitionSystemDlg::FeatureDetect(const Mat& image_input, Mat& image_output) { image_input.copyTo(image_output); cvtColor(image_output, image_output, CV_BGR2GRAY); #ifdef _DEBUG TRACE("gray image channels = %d\n", image_output.channels()); #endif // morphology Mat kernel = Mat(3,3,CV_8UC1, Scalar(255)); morphologyEx(image_output, image_output, MORPH_OPEN, kernel); // floodfill int num_floodfill = 0; int area_max = 0; int value_max = 0; for (int i = 0; i < image_output.rows; i++) { unsigned char* p_out = image_output.ptr<uchar>(i); for (int j = 0; j < image_output.cols; j++) { if (*(p_out + j) == 255) { num_floodfill++; Scalar new_val = Scalar(num_floodfill); Point seed = Point(j, i); CRect rect; int area = floodFill(image_output,seed, new_val); if (area > area_max) { area_max = area; value_max = num_floodfill; } } } } // max area int area_left = image_output.cols; int area_right = 0; int area_top = image_output.rows; int area_buttom = 0; for (int i = 0; i < image_output.rows; i++) { unsigned char* p_out = image_output.ptr<uchar>(i); for (int j = 0; j < image_output.cols; j++) { if (*(p_out + j) == value_max) { *(p_out + j) = 255; if (area_left > j) area_left = j; if (area_right < j) area_right = j; if (area_top > i) area_top = i; if (area_buttom < i) area_buttom = i; } else { *(p_out + j) = 0; } } } #ifdef _DEBUG TRACE("area_left = %d\n", area_left); TRACE("area_right = %d\n", area_right); TRACE("area_top = %d\n", area_top); TRACE("area_buttom = %d\n", area_buttom); #endif // rectangle rectangle(image_output, Point(area_left, area_top), Point(area_right, area_buttom), Scalar(255), 5); // moment Moments moment = moments(image_output); int center_x = moment.m10 / moment.m00; int center_y = moment.m01 / moment.m00; point_end = Point(center_x, center_y); circle(image_output, point_end, 10, Scalar(255), 5); GetVector(point_begin, point_end); if (vector_length >= 20 || point_begin == Point(image_width / 2, image_height / 2)) { point_begin = point_end; } #ifdef _DEBUG TRACE("vector_length = %f\n", vector_length); TRACE("vector_angle = %f\n", vector_angle); #endif return image_output; }
BOOL CSpotsMainDlg::OnInitDialog() { CDialogEx::OnInitDialog(); // 设置此对话框的图标。 当应用程序主窗口不是对话框时,框架将自动 // 执行此操作 SetIcon(m_hIcon, TRUE); // 设置大图标 SetIcon(m_hIcon, FALSE); // 设置小图标 // TODO: 在此添加额外的初始化代码 // 打开控制台 if (__argc > 1) { for (size_t i = 0; i < __argc; i++) { CString targv = __targv[i]; if (targv == L"debug")//输出命令台 { MFCConsole::Init(); MFCConsole::Output("Debug start.\r\n"); } if (targv == L"virtual") { p_contrller->IsRealModel = 0; } } } //p_contrller->IsRealModel = 0; // 添加菜单栏 ModifyStyle(WS_THICKFRAME, DS_MODALFRAME); menu.LoadMenuW(IDR_MenuMain); SetMenu(&menu); int Standard_Width_mm = 0; if (SettingHelper::GetKeyInt("SYS_IMG_CAPTURE", "Standard_Width_mm", Standard_Width_mm)) GetDlgItem(IDC_TB_Real_WidthMM)->SetWindowText(StringHelper::int2CString(Standard_Width_mm)); else GetDlgItem(IDC_TB_Real_WidthMM)->SetWindowText(L"600"); int Standard_Length_mm = 0; if (SettingHelper::GetKeyInt("SYS_IMG_CAPTURE", "Standard_Length_mm", Standard_Length_mm)) GetDlgItem(IDC_TB_Real_LengthMM)->SetWindowText(StringHelper::int2CString(Standard_Length_mm)); else GetDlgItem(IDC_TB_Real_LengthMM)->SetWindowText(L"300"); //系统初始化 p_contrller->Init(); CSliderCtrl *pSlidCtrl = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_IMG_X); pSlidCtrl->EnableWindow(0); pSlidCtrl = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_IMG_Y); pSlidCtrl->EnableWindow(0); pSlidCtrl = 0; /***************保存控件初始位置,用于自适应窗口缩放******************/ save1control(0);//保存主窗口 save1control(IDC_BTN_SelectVirtualImg); save1control(IDC_BTN_virtualTigger); save1control(IDC_BTN_TriggerContinue); save1control(IDC_BTN_PlaneArray); save1control(IDC_BTN_PlaneArraySolo); save1control(IDC_BTN_RUN); save1control(IDCANCEL); save1control(IDC_GB_IMG_BIG); save1control(IDC_IMG_BIG); save1control(IDC_LABLE_IMG_INFO); save1control(IDC_SLIDER_IMG_X); save1control(IDC_SLIDER_IMG_Y); save1control(IDC_GB_LogImg); save1control(IDC_IMG_HISTORY); save1control(IDC_GB_STATISTIC); save1control(IDC_LB11); save1control(IDC_LB7); save1control(IDC_LB8); save1control(IDC_LB9); save1control(IDC_LB10); save1control(IDC_LB12); save1control(IDC_LB4); save1control(IDC_LB5); save1control(IDC_LB6); save1control(IDC_LB_todayTotal); save1control(IDC_LB_todayA); save1control(IDC_LB_todayB); save1control(IDC_LB_todayC); save1control(IDC_LB_todayGood); save1control(IDC_LB_dayFineRate); save1control(IDC_LB_monthTotal); save1control(IDC_LB_monthA); save1control(IDC_LB_monthB); save1control(IDC_LB_monthC); save1control(IDC_LB_monthGood); save1control(IDC_LB_monthFineRate); save1control(IDC_LB_yearTotal); save1control(IDC_LB_yearA); save1control(IDC_LB_yearB); save1control(IDC_LB_yearC); save1control(IDC_LB_yearGood); save1control(IDC_LB_yearFineRate); save1control(IDC_LB_SIZESHOW); save1control(IDC_GB_SIZE); save1control(IDC_LB_SZIE_X); save1control(IDC_TB_Real_WidthMM); save1control(IDC_LB_SIZE_Y); save1control(IDC_TB_Real_LengthMM); save1control(IDC_BTN_SizeDingBiao); save1control(IDC_MAIN_DINGBIAO); string MainHSVs; if (SettingHelper::GetKeyString("AreaCam", "MainHSVs", MainHSVs)) GetDlgItem(IDC_MAIN_HSV)->SetWindowText(StringHelper::string2CString(MainHSVs)); else GetDlgItem(IDC_MAIN_HSV)->SetWindowText(L"300"); FileStorage fs("data//histdata.yaml", FileStorage::READ);//历史样本图片导入 fs["hissample"] >> SampleImg_cache; fs.release(); if (SampleImg_cache.empty()) SampleImg_cache = Mat(70, 10, CV_8UC1, Scalar(255)); initEndFlag = true; return TRUE; // 除非将焦点设置到控件,否则返回 TRUE }
Leap::Vector GetTrackedPoint(Leap::Image image) { Mat img = Mat(image.height(), image.width(), CV_8UC1); img.data = (unsigned char*)image.data(); Mat cimg = img.clone(); CvSize size = img.size(); //binary threshold, val = 235 threshold(img, cimg, 235, 255, 0); medianBlur(cimg, cimg, 5); //circle detection with contours bool enableRadiusCulling = false; int minTargetRadius = 5; vector<vector<Point> > contours; vector<Vec4i> heirarchy; findContours(cimg, contours, heirarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE); size_t count = contours.size(); //get circle with largest radius float radius = 0; Point2i center; for (int i = 0; i < count; i++) { Point2f c; float r; minEnclosingCircle(contours[i], c, r); if (!enableRadiusCulling || r >= minTargetRadius) { if (r > radius) { radius = r; center = (Point2i)c; } } } Leap::Vector res; res.x = center.x; res.y = center.y; res.z = 0; /* cvtColor(cimg, cimg, CV_GRAY2BGR); Scalar red(0, 0, 255); Scalar blue(255, 0, 0); if (radius > 0) { //circle was found circle(cimg, center, radius, red, 1); circle(cimg, center, 1, blue, 2); //cout << "Center: " << center.x << "; " << center.y << "\n"; } imshow("detected circles", cimg); */ return res; }
int StateIdentifier::recognize(Mat img, Rect frame, char* stateCode) { Mat croppedImage = Mat(img, frame); return this->recognize(croppedImage, stateCode); }
const Mat DirectoryImageSource::getImage() const { if (index < 0 || index >= files.size()) return Mat(); return imread(files[index].string(), CV_LOAD_IMAGE_COLOR); }