void RenderContourBounds(CVPipeline * pipe) { rng = cv::RNG(5553); for (int i = 0; i < pipe->contours.Size(); ++i) { CVContour * contour = &pipe->contours[i]; cv::Scalar color; switch(contour->contourClass) { case ContourClass::FINGERTIP: color = cv::Scalar(255, 0, 0); break; case ContourClass::FINGER: color = cv::Scalar(0, 255, 0); break; default: color = cv::Scalar(rng.uniform(0,225), rng.uniform(0,225), rng.uniform(0,255)); } switch(contour->boundingType) { case BoundingType::ELLIPSE: // ellipse ellipse(pipe->output, contour->boundingEllipse, color, 2, 8 ); break; case BoundingType::RECT: { // rotated rectangle cv::Point2f rect_points[4]; contour->boundingRect.points( rect_points ); for( int j = 0; j < 4; j++ ) line(pipe->output, rect_points[j], rect_points[(j+1)%4], color, 1, 8 ); break; } } } }
Plane() { n[0] = rng.uniform(-0.5, 0.5); n[1] = rng.uniform(-0.5, 0.5); n[2] = -0.3; //rng.uniform(-1.f, 0.5f); n = n / cv::norm(n); set_d(rng.uniform(-2.0, 0.6)); }
void RenderPolygons(CVPipeline * pipe) { /// Use same random seed every time to avoid rainbow hell.. rng = cv::RNG(12345); for (int i = 0; i < pipe->approximatedPolygons.size(); ++i) { cv::Scalar color = cv::Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)); cv::drawContours(pipe->output, pipe->approximatedPolygons, i, color, 2, 8, pipe->contourHierarchy, 0, cv::Point()); } }
const cv::Vec3b Brush::get_color(const cv::Point center, const cv::Mat& reference_image, const Style& style) const { cv::Vec3b color = reference_image.at<cv::Vec3b>(center); color[0] = clamp(color[0] + color[0] * (rng.uniform(-0.5, 0.5) * style.blue_jitter())); color[1] = clamp(color[1] + color[1] * (rng.uniform(-0.5, 0.5) * style.green_jitter())); color[2] = clamp(color[2] + color[2] * (rng.uniform(-0.5, 0.5) * style.red_jitter())); cv::cvtColor(color, color, CV_RGB2HSV); color[0] = clamp(color[0] + color[0] * (rng.uniform(-0.5, 0.5) * style.hue_jitter())); color[1] = clamp(color[1] + color[1] * (rng.uniform(-0.5, 0.5) * style.saturation_jitter())); color[2] = clamp(color[2] + color[2] * (rng.uniform(-0.5, 0.5) * style.value_jitter())); cv::cvtColor(color, color, CV_HSV2RGB); return color; }
void cannyDetector(cv::Mat src, cv::Mat &imgMap) { /*Obsolete version for detection of colored contours... date : */ int ratio = 3; int kernel_size = 3; cv::Mat srcGray, srcHsv, cannyOutput; std::vector<std::vector<cv::Point> > contours; // from color to gray cv::cvtColor(src, srcGray, cv::COLOR_BGR2GRAY); // from color to hsv cv::cvtColor(src, srcHsv, cv::COLOR_BGR2HSV); /// Reduce noise with a kernel 3x3 cv::blur( srcGray, srcGray, cv::Size(3,3) ); /// Canny detector cv::Canny( srcGray, cannyOutput, lowThreshold, lowThreshold*ratio, kernel_size ); /// Find contours cv::findContours(cannyOutput, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE); // Select orange contours imgMap = cv::Mat::zeros( srcGray.size(), srcGray.type() ); cv::Rect bRect = cv::Rect(0,0,0,0); for( int i = 0; i< contours.size(); i++ ) { if (cv::contourArea(contours[i]) > 0.00001*src.rows*src.cols) { bRect = cv::boundingRect(contours[i]); cv::inRange(srcHsv(bRect), cv::Scalar(h_min,50,50), cv::Scalar(h_max,255,255), imgMap(bRect)); } } cv::erode(imgMap, imgMap, getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(1, 1))); cv::dilate(imgMap, imgMap, getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(3, 3))); //Draw contours cv::Mat drawing = cv::Mat::zeros( cannyOutput.size(), CV_8UC3 ); for( int i = 0; i< contours.size(); i++ ) { cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); drawContours( drawing, contours, i, cv::Scalar(0,0,255), 1, 8); } /*// Show in a window cv::namedWindow( "Contours", CV_WINDOW_AUTOSIZE ); cv::imshow( "Contours", drawing ); cv::namedWindow( "imgMap", CV_WINDOW_AUTOSIZE ); cv::imshow( "imgMap", imgMap );*/ }
void RenderConvexityDefects(CVPipeline * pipe) { cv::Scalar color = cv::Scalar(rng.uniform(155,255), rng.uniform(125,255), rng.uniform(0,200)); List<cv::Vec4i> defects = pipe->convexityDefects; for (int i = 0; i < defects.Size(); ++i) { cv::Vec4i defect = defects[i]; int farthestPointIndex = defect[2]; cv::Point farthestPoint = pipe->cvContours[0][farthestPointIndex]; // Render point furthest away? cv::circle(pipe->output, farthestPoint, 3, color, 5); } }
void CornerDetection::myShiTomasi_function(cv::Mat img, cv::Mat img_gray, cv::Mat myShiTomasi_dst) { myShiTomasi_copy = img.clone(); if( myShiTomasi_qualityLevel < 1 ) myShiTomasi_qualityLevel = 1; for( int j = 0; j < img_gray.rows; j++ ) for( int i = 0; i < img_gray.cols; i++ ) if( myShiTomasi_dst.at<float>(j,i) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel ) cv::circle( myShiTomasi_copy, cv::Point(i,j), 4, cv::Scalar( rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255) ), -1, 8, 0 ); cv::imshow( shiTomasi_win, myShiTomasi_copy ); }
void DataProviderDTang<Dtype>::shuffle() { static cv::RNG rng(time(0)); std::vector<boost::filesystem::path> shuffled_depth_paths(depth_paths_.size()); std::vector<std::vector<cv::Vec3f> > shuffled_annos(annos_.size()); for(size_t idx = 0; idx < depth_paths_.size(); ++idx) { int rand_idx = rng.uniform(0, depth_paths_.size()); shuffled_depth_paths[idx] = depth_paths_[rand_idx]; shuffled_annos[idx] = annos_[rand_idx]; } depth_paths_ = shuffled_depth_paths; annos_ = shuffled_annos; }
void RenderContours(CVPipeline * pipe) { /// Use same random seed every time to avoid rainbow hell.. rng = cv::RNG(12345); for (int i = 0; i < pipe->contours.Size(); ++i) { CVContour * contour = &pipe->contours[i]; if (contour->segments.Size()) RenderContourSegments(contour, pipe); else { cv::Scalar color = cv::Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)); cv::drawContours(pipe->output, pipe->cvContours, i, color, 2, 8, pipe->contourHierarchy, 0, cv::Point()); } } }
double randomDoubleLog(double minVal, double maxVal) { double logMin = log((double)minVal + 1); double logMax = log((double)maxVal + 1); double pow = rng.uniform(logMin, logMax); double v = exp(pow) - 1; CV_Assert(v >= minVal && (v < maxVal || (v == minVal && v == maxVal))); return v; }
void RenderConvexHulls(CVPipeline * pipe) { if (pipe->cvContours.size() == 0) return; cv::Scalar color = cv::Scalar(rng.uniform(125,255), rng.uniform(125,255), rng.uniform(125,255)); // cv::drawContours(pipe->output, pipe->convexHull, 0, color, 1, 8, std::vector<cv::Vec4i>(), 0, cv::Point() ); std::vector<int> & convexHull = pipe->convexHull; std::vector<cv::Point> & contour = pipe->cvContours[0]; for (int i = 0; i < convexHull.size(); ++i) { int index = convexHull[i]; cv::Point point = contour[index]; cv::circle(pipe->output, point, 15, color); int nextIndex = convexHull[(i+1) % convexHull.size()]; cv::Point point2 = contour[nextIndex]; // Line! cv::line(pipe->output, point, point2, color, 3); } }
Rectangle::Rectangle(const cv::Rect &_rect, const int &_id) : rect(_rect) { tl = _rect.tl(); br = _rect.br(); left = new VerticalLine(); left->set(tl, cv::Point(tl.x, br.y)); top = new HorizontalLine(); top->set(tl, cv::Point(br.x, tl.y)); bottom = new HorizontalLine(); bottom->set(cv::Point(tl.x, br.y), br); right = new VerticalLine(); right->set(cv::Point(br.x, tl.y), br); info.set(_id, _rect); selected = false; selected_color = RED_COLOR; offset = 4; lineOffset = LINE_WEIGHT; color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); }
void drawEpipolar( cv::Mat _imga, cv::Mat _imgb, std::vector<Eigen::VectorXi> _p2Da, std::vector<Eigen::VectorXi> _p2Db, std::vector<Eigen::VectorXd> _pda, std::vector<Eigen::VectorXd> _pdb ) { char num[] = "12"; for( unsigned int i = 0; i < _p2Da.size(); i++ ) { Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255) ); sprintf( num, "%d ", i); circle( _imga, Point( _p2Da[i](0), _p2Da[i](1)), 5, color, -1, 8, 0 ); putText( _imga, num, Point( _p2Da[i](0), _p2Da[i](1) ), FONT_HERSHEY_SIMPLEX, 1, color, 2, 8, false); sprintf( num, "%d ", i); circle( _imgb, Point( _p2Db[i](0), _p2Db[i](1)), 5, color, -1, 8, 0 ); putText( _imgb, num, Point( _p2Db[i](0), _p2Db[i](1) ), FONT_HERSHEY_SIMPLEX, 1, color, 2, 8, false); Point2f pt1a; Point2f pt2a; pt1a.x = _pda[i](0); pt1a.y = _pda[i](1); pt2a.x = _pda[i](2); pt2a.y = _pda[i](3); line( _imga, pt1a, pt2a, color, 2, CV_AA ); Point2f pt1b; Point2f pt2b; pt1b.x = _pdb[i](0); pt1b.y = _pdb[i](1); pt2b.x = _pdb[i](2); pt2b.y = _pdb[i](3); line( _imgb, pt1b, pt2b, color, 2, CV_AA ); } }
void CropIm(std::string destFoldPath, cv::Mat Im, double s) { int w = Im.rows; int h = Im.cols; int wStart; int hStart; wStart = rng.uniform(0.0, w*(1-s)); hStart = rng.uniform(0.0, h*(1-s)); cv::Rect myROI(hStart, wStart, h*s, w*s); cv::Mat croppedImage = Im(myROI); cv::imwrite(destFoldPath + "_crop" + int2string(int(s * 100)) + ".jpg", croppedImage); }
void gen_points_3d(std::vector<Plane>& planes_out, cv::Mat_<unsigned char> &plane_mask, cv::Mat& points3d, cv::Mat& normals, int n_planes) { std::vector<Plane> planes; for (int i = 0; i < n_planes; i++) { Plane px; for (int j = 0; j < 1; j++) { px.set_d(rng.uniform(-3.f, -0.5f)); planes.push_back(px); } } cv::Mat_ < cv::Vec3f > outp(H, W); cv::Mat_ < cv::Vec3f > outn(H, W); plane_mask.create(H, W); // n ( r - r_0) = 0 // n * r_0 = d // // r_0 = (0,0,0) // r[0] for (int v = 0; v < H; v++) { for (int u = 0; u < W; u++) { unsigned int plane_index = (u / float(W)) * planes.size(); Plane plane = planes[plane_index]; outp(v, u) = plane.intersection(u, v, Kinv); outn(v, u) = plane.n; plane_mask(v, u) = plane_index; } } planes_out = planes; points3d = outp; normals = outn; }
cv::Mat PerspectiveTransform::warpPerspectiveRand( cv::RNG& rng ) { cv::Mat H; H.create(3, 3, CV_64FC1); H.at<double>(0,0) = rng.uniform( 0.8f, 1.2f); H.at<double>(0,1) = rng.uniform(-0.1f, 0.1f); //H.at<double>(0,2) = rng.uniform(-0.1f, 0.1f)*src.cols; H.at<double>(0,2) = rng.uniform(-0.1f, 0.1f); H.at<double>(1,0) = rng.uniform(-0.1f, 0.1f); H.at<double>(1,1) = rng.uniform( 0.8f, 1.2f); //H.at<double>(1,2) = rng.uniform(-0.1f, 0.1f)*src.rows; H.at<double>(1,2) = rng.uniform(-0.1f, 0.1f); H.at<double>(2,0) = rng.uniform( -1e-4f, 1e-4f); H.at<double>(2,1) = rng.uniform( -1e-4f, 1e-4f); H.at<double>(2,2) = rng.uniform( 0.8f, 1.2f); return H; }
void thresh_callback(int, void* ) { cv::Mat canny_output; std::vector<std::vector<cv::Point> > contours; std::vector<cv::Vec4i> hierarchy; /// Detect edges using canny cv::threshold( blur, canny_output, thresh, 255 ,1 ); cv::namedWindow("canny",CV_WINDOW_NORMAL); cv::imshow("canny",canny_output); /// Find contours cv::findContours( canny_output, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0, 0) ); for( int f =0; f <listOfMarks.size();f++) { delete listOfMarks[f]; } listOfMarks.clear(); /// Draw contours cv::Mat drawing = cv::Mat::zeros( canny_output.size(), CV_8UC3 ); for( size_t i = 0; i< contours.size(); i++ ) { cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); cv::drawContours( drawing, contours, (int)i, cv::Scalar(255,255,255), thick, 8, hierarchy, 0, cv::Point() ); // mark *temp = new mark(contours[i]); // listOfMarks.push_back(temp); } /// Show in a window cv::namedWindow( "Contours", CV_WINDOW_NORMAL ); cv::imshow( "Contours", drawing ); //-------------------------------------------again std::vector<std::vector<cv::Point> > contours_again; std::vector<cv::Vec4i> hierarchy_again; draw_again = cv::Mat::zeros( canny_output.size(), CV_8UC3 ); colorOutImage = cv::Mat::zeros(canny_output.size(), CV_8UC3); cv::Mat temp; cv::cvtColor( drawing,temp, cv::COLOR_BGR2GRAY ); cv::findContours( temp , contours_again, hierarchy_again, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0, 0) ); for( size_t i = 0; i< contours_again.size(); i++ ) { // cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); cv::Scalar color = cv::Scalar(255,255,255); cv::drawContours( draw_again, contours_again, (int)i, color , 2, 8, hierarchy, 0, cv::Point() ); mark * temp = new mark(contours_again[i]); listOfMarks.push_back(temp); } /// Show in a window // cv::namedWindow( "Contours_again", CV_WINDOW_NORMAL ); // cv::imshow( "Contours_again", draw_again ); for(int h = 0; h < listOfMarks.size();h++) { int y = (listOfMarks[h]->high_y() + listOfMarks[h]->low_y()) / 2; int x1 = listOfMarks[h]->high_x() + length; int x2 = listOfMarks[h]->low_x() - length; cv::Point one = cv::Point(x1,y); cv::Point two = cv::Point(x2,y); cv::Scalar white =cv::Scalar(255,255,255); cv::line(draw_again, one, two, white, thick,8,0); } cv::namedWindow( "Contours_again", CV_WINDOW_NORMAL ); cv::imshow( "Contours_again", draw_again ); std::vector< std::vector<cv::Point> > contour_3; std::vector<cv::Vec4i> hierarchy_3; cv::Mat temp_3; cv::cvtColor( draw_again,temp_3, cv::COLOR_BGR2GRAY ); std::cerr<<"cvtColo" <<std::endl; cv::findContours( temp_3, contour_3, hierarchy_3, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0, 0) ); std::cerr<<"found contours" << std::endl; for( size_t i = 0; i< contour_3.size(); i++ ) { cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); // cv::Scalar color = cv::Scalar(255,255,255); cv::drawContours( colorOutImage, contour_3, (int)i, color , 2, 8, hierarchy_3, 0, cv::Point() ); } std::cerr<<"drawContours"<<std::endl; cv::namedWindow( "Contours_3", CV_WINDOW_NORMAL ); cv::imshow( "Contours_3", colorOutImage ); std::cout<<std::endl<<"number of contours -> " <<contours.size(); //again-------------------------------------------------------------------------- // makeZones_callback(0,0); }
void getDistortionValues(cv::RNG &rng, const Size2i &inputSize, AugParams *agp) { // This function just gets the random distortion values without modifying the // image itself. Useful if we need to reapply the same transformations over // again (e.g. for all frames of a video or for a corresponding target mask) // colornoise values // N.B. if _contrastMax == 100, then _colorNoiseStd will be 0.0 for (int i=0; i<3; i++) { agp->colornoise[i] = rng.gaussian(_colorNoiseStd); } // contrast, brightness, saturation // N.B. all value ranges tied to _contrastMin and _contrastMax for (int i=0; i<3; i++) { agp->cbs[i] = rng.uniform(_contrastMin, _contrastMax) / 100.0f; } /************************** * HORIZONTAL FLIP * ***************************/ agp->flip = _flip && rng(2) != 0 ? true : false; /************************** * ROTATION ANGLE * ***************************/ agp->angle = rng.uniform(_rotateMin, _rotateMax); /************************** * CROP BOX * ***************************/ float shortSide = std::min(inputSize.height, inputSize.width); // Special case where we just grab the whole image; if (_scaleMin == 0) { agp->cropBox = Rect(Point2i(), inputSize); return; } if (_center) { agp->cropBox.width = shortSide * _width / (float) _scaleMin; agp->cropBox.height = shortSide * _height / (float) _scaleMin; agp->cropBox.x = (inputSize.width - agp->cropBox.width) / 2; agp->cropBox.y = (inputSize.height - agp->cropBox.height) / 2; } else { cv::Size2f oSize = inputSize; // This is a hack for backward compatibility. // Valid aspect ratio range ( > 100) will override side scaling behavior if (_aspectRatio == 0) { float scaleFactor = rng.uniform(_scaleMin, _scaleMax); agp->cropBox.width = shortSide * _width / scaleFactor; agp->cropBox.height = shortSide * _height / scaleFactor; } else { float mAR = (float) _aspectRatio / 100.0f; float nAR = rng.uniform(1.0f / mAR, mAR); float oAR = oSize.width / oSize.height; // between minscale pct% to 100% subject to aspect ratio limitation float maxScale = nAR > oAR ? oAR / nAR : nAR / oAR; float minScale = std::min((float) _scaleMin / 100.0f, maxScale); float tgtArea = rng.uniform(minScale, maxScale) * oSize.area(); agp->cropBox.height = sqrt(tgtArea / nAR); agp->cropBox.width = agp->cropBox.height * nAR; } agp->cropBox.x = rng.uniform(0, inputSize.width - agp->cropBox.width); agp->cropBox.y = rng.uniform(0, inputSize.height - agp->cropBox.height); } return; }
int main( int argc, char** argv ) { /// Load an image cv::Mat src, greyIm, histeqIm; src = cv::imread( argv[1] ); if( !src.data ) { printf("Input file? No? ouuuupsss thooooorryyyyy\n"); return -1; } cv::Size s = src.size(); int rows = s.height; int cols = s.width; // Setup a rectangle to define your region of interest cv::Rect myROI(0, rows/2, cols, rows/2); // Crop the full image to that image contained by the rectangle myROI // Note that this doesn't copy the data cv::Mat croppedImage = src(myROI); cv::imwrite("output/1_low_half.jpg", croppedImage); cv::cvtColor(croppedImage, greyIm, cv::COLOR_BGR2GRAY); cv::Size crop_size = croppedImage.size(); int crop_rows = crop_size.height; int crop_cols = crop_size.width; cv::imwrite("output/2_grey_scale.jpg", greyIm); cv::equalizeHist( greyIm, histeqIm ); cv::imwrite("output/3_hist_eq.jpg", histeqIm); std::vector<std::vector<cv::Point> > contours; std::vector<cv::Vec4i> hierarchy; // Reduce noise with kernel 3x3 cv::Mat blurIm; blur(histeqIm, blurIm, cv::Size(3,3)); cv::imwrite("output/4_blur.jpg", blurIm); // Canny detector cv::Mat edgesIm; Canny(blurIm, edgesIm, thresh, thresh*ratio, kernel_size); cv::imwrite("output/5_edge.jpg", edgesIm); // Find contours cv::findContours(edgesIm, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE, cv::Point(0,0)); // Approximate contours to polygons + get bounding rects and circles std::vector<std::vector<cv::Point> > contours_poly(contours.size()); std::vector<cv::Rect> boundRect(contours.size()); std::vector<cv::Point2f>center(contours.size()); std::vector<float>radius(contours.size()); for (int i = 0; i < contours.size(); i++) { cv::approxPolyDP(cv::Mat(contours[i]), contours_poly[i], 3, true); boundRect[i] = cv::boundingRect(cv::Mat(contours_poly[i])); cv::minEnclosingCircle((cv::Mat)contours_poly[i], center[i], radius[i]); } // Draw contours int j=0; cv::Mat drawing = cv::Mat::zeros(edgesIm.size(), CV_8UC3); cv::Mat piece[5], hsvIm[5]; for (int i = 0; i < contours.size(); i++) { if (!((boundRect[i].height >= boundRect[i].width/5) && (boundRect[i].height <= boundRect[i].width/2) && boundRect[i].height<=crop_rows/4 && boundRect[i].width<=crop_cols/2 && boundRect[i].height>=crop_rows/10 && boundRect[i].width>=crop_cols/6)) continue; cv::Rect roi = boundRect[i]; piece[j] = croppedImage(roi); imwrite("output/contour"+std::to_string(j)+".jpg", piece[j]); j++; cv::Scalar color = cv::Scalar(rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255)); cv::drawContours(drawing, contours, i, color, 2, 8, hierarchy, 0, cv::Point()); cv::rectangle(drawing, boundRect[i].tl(), boundRect[i].br(), color, 2, 8, 0); //circle(drawing, center[i], (int)radius[i], color, 2, 8, 0); } imwrite("output/6_contours.jpg", drawing); int h_bins = 50; int s_bins = 60; int histSize[] = { h_bins, s_bins }; float h_ranges[] = { 0, 180 }; float s_ranges[] = { 0, 256 }; const float* ranges[] = { h_ranges, s_ranges }; int channels[] = { 0, 1 }; cv::Mat hist[5]; for (int i=0; i<j; i++){ cvtColor(piece[i], hsvIm[i], cv::COLOR_BGR2HSV); imwrite("output/hsvIm"+std::to_string(i)+".jpg", hsvIm[i]); calcHist( &hsvIm[i], 1, channels, cv::Mat(), hist[i], 2, histSize, ranges, true, false ); //normalize( hsvIm[i], hsvIm[i], 0, 1, cv::NORM_MINMAX, -1, cv::Mat() ); } return 0; }
void CVDataFilter::Paint(CVPipeline * pipe) { if (returnType == CVReturnType::QUADS) { // Draw quads. if (!pipe->quads.Size()) return; // Copy original input pipe->initialInput.copyTo(pipe->output); // Convert to color if needed. int channelsBefore = pipe->output.channels(); if (channelsBefore == 1) { // pipe->output.convertTo(pipe->output, CV_8UC3); cv::cvtColor(pipe->output, pipe->output, CV_GRAY2RGB); } int channelsAfter = pipe->output.channels(); // o.o Paste! for (int i = 0; i < pipe->quads.Size(); ++i) { Quad quad = pipe->quads[i]; #define RGB(r,g,b) cv::Scalar(b,g,r) rng = cv::RNG(1344); cv::Scalar color = RGB(rng.uniform(0, 255),rng.uniform(0, 255),rng.uniform(0, 255)); // cv::Mat rectImage = cv::Mat::zeros(pipe->output.size(), CV_8UC3); cv::rectangle(pipe->output, cv::Point(quad.point1.x, quad.point1.y), cv::Point(quad.point3.x, quad.point3.y), color, CV_FILLED); float alpha = 0.2f; float beta = 1 - alpha; // cv::addWeighted(rectImage, alpha, pipe->output, beta, 0.0, pipe->output); // rectImage.copyTo(pipe->output); } } else if (returnType == CVReturnType::APPROXIMATED_POLYGONS) { // Copy original input.. pipe->initialInput.copyTo(pipe->output); RenderPolygons(pipe); } else if (returnType == CVReturnType::CV_IMAGE) { // Do nothing as the image should already be in the ouput matrix of the pipeline. } else if (returnType == CVReturnType::LINES || returnType == CVReturnType::CV_LINES) { // Convert the color to colors again for visualization... pipe->initialInput.copyTo(pipe->output); for( size_t i = 0; i < pipe->lines.Size(); i++ ) { Line & line = pipe->lines[i]; // Multiply the line coordinates with the last used inverted scale. line.start *= pipe->currentScaleInv; line.stop *= pipe->currentScaleInv; cv::line( pipe->output, cv::Point(line.start.x, line.start.y), cv::Point(line.stop.x, line.stop.y), cv::Scalar(0,0,255), 3, 8 ); } } else if (returnType == CVReturnType::CV_CONTOURS) { pipe->initialInput.copyTo(pipe->output); RenderContours(pipe); } switch(returnType) { case CVReturnType::CV_CONTOUR_SEGMENTS: { // Render shit! pipe->initialInput.copyTo(pipe->output); RenderContourSegments(pipe); break; } } if (returnType == CVReturnType::CV_CONTOUR_ELLIPSES) { pipe->initialInput.copyTo(pipe->output); RenderContours(pipe); RenderContourBounds(pipe); } else if (returnType == CVReturnType::CV_CONVEX_HULLS) { pipe->initialInput.copyTo(pipe->output); RenderContours(pipe); RenderConvexHulls(pipe); } else if (returnType == CVReturnType::CV_CONVEXITY_DEFECTS) { pipe->initialInput.copyTo(pipe->output); RenderContours(pipe); RenderConvexHulls(pipe); RenderConvexityDefects(pipe); } else if (returnType == CVReturnType::HANDS) { // Convert image to RGB for easier display int channelsBefore = pipe->initialInput.channels(); // cv::cvtColor(*pipe->initialInput, pipe->output, CV_GRAY2RGB); pipe->initialInput.copyTo(pipe->output); int channelsAfter = pipe->output.channels(); // Check if we got contour-segments, if so prioritize them. RenderHands(pipe); } else if (returnType == CVReturnType::FINGER_STATES) { // Render the last known one. pipe->initialInput.copyTo(pipe->output); FingerState & state = pipe->fingerStates.Last(); cv::Scalar color(255,0,0,255); for (int i = 0; i < state.positions.Size(); ++i) { Vector3f pos = state.positions[i]; cv::circle(pipe->output, cv::Point(pos.x, pos.y), 5, color, 3); } } else if (returnType == CVReturnType::POINT_CLOUDS) { pipe->initialInput.copyTo(pipe->output); for (int i = 0; i < pipe->pointClouds.Size(); ++i) { int r,g,b,a; r = g = b = a = 255; if (i % 2 == 0) g = 0; if (i % 4 == 0) b = 0; cv::Scalar color(r,g,b,a); CVPointCloud & pc = pipe->pointClouds[i]; for (int j = 0; j < pc.points.Size(); ++j) { Vector2f & pos = pc.points[j]; cv::circle(pipe->output, cv::Point(pos.x, pos.y), 2, color, 3); } /// Render PCA data if applicable. for (int j = 0; j < pc.eigenVectors.Size(); ++j) { cv::Scalar color = j == 0? CV_RGB(255, 255, 0) : CV_RGB(0, 255, 255); cv::Point2f eigenVector(pc.eigenVectors[j].x, pc.eigenVectors[j].y); float eigenValue = pc.eigenValues[j]; cv::Point2f scaledEigenVector = eigenVector * eigenValue * 0.02; cv::Point2f pcaCenter(pc.pcaCenter.x, pc.pcaCenter.y); circle(pipe->output, pcaCenter, 3, CV_RGB(255, 0, 255), 2); line(pipe->output, pcaCenter, pcaCenter + scaledEigenVector, color); } } } else if (returnType == CVReturnType::CV_OPTICAL_FLOW) { // http://stackoverflow.com/questions/7693561/opencv-displaying-a-2-channel-image-optical-flow // Split the coordinates. /* cv::Mat xy[2]; cv::split(pipe->opticalFlow, xy); cv::Mat magnitude, angle; // Fetch matrix from pipeline. cv::cartToPolar(xy[0], xy[1], magnitude, angle, true); double magMax; cv::minMaxLoc(magnitude, 0, &magMax); magnitude.convertTo(magnitude, -1, 1.0 / magMax); // Build HSV image? cv::Mat hsvChannels[3], hsv; hsvChannels[0] = angle; hsvChannels[1] = cv::Mat::ones(angle.size(), CV_32F); hsvChannels[2] = magnitude; cv::merge(hsvChannels, 3, hsv); // Convert to rgb and send to output. cv::cvtColor(hsv, pipe->output, cv::COLOR_HSV2RGB); */ } else if (returnType == CVReturnType::NOTHING) { // Nothing to render... } else if (returnType == -1) { // Nothing to render if error. std::cout<<"\nreturnType variable in filter "<<name<<" not set!"; } else if (returnType == CVReturnType::RENDER) // Nothing to render if render. ; else ; // std::cout<<"\nCVDataFilter::Paint called. Forgot to subclass the paint-method?"; }
JNIEXPORT void JNICALL Java_ph_edu_dlsu_circles_CameraActivity_process(JNIEnv *env, jobject instance, jobject pTarget, jbyteArray pSource, jint thresh) { uint32_t t; cv::Mat srcBGR; cv::Mat edges; cv::Scalar color; std::vector<cv::Vec3f> circles; AndroidBitmapInfo bitmapInfo; uint32_t* bitmapContent; if(AndroidBitmap_getInfo(env, pTarget, &bitmapInfo) < 0) abort(); if(bitmapInfo.format != ANDROID_BITMAP_FORMAT_RGBA_8888) abort(); if(AndroidBitmap_lockPixels(env, pTarget, (void**)&bitmapContent) < 0) abort(); /// Access source array data... OK jbyte* source = (jbyte*)env->GetPrimitiveArrayCritical(pSource, 0); if (source == NULL) abort(); /// cv::Mat for YUV420sp source and output BGRA cv::Mat srcGray(bitmapInfo.height, bitmapInfo.width, CV_8UC1, (unsigned char *)source); cv::Mat src(bitmapInfo.height + bitmapInfo.height/2, bitmapInfo.width, CV_8UC1, (unsigned char *)source); cv::Mat mbgra(bitmapInfo.height, bitmapInfo.width, CV_8UC4, (unsigned char *)bitmapContent); /***********************************************************************************************/ /// Native Image Processing HERE... t = cv::getTickCount(); if(srcBGR.empty()) srcBGR = cv::Mat(bitmapInfo.height, bitmapInfo.width, CV_8UC3); cv::cvtColor(src, srcBGR, CV_YUV420sp2RGB); // Reduce noise cv::GaussianBlur( srcGray, srcGray, cv::Size(9, 9), 2, 2 ); // Detect the circles cv::HoughCircles(srcGray, circles, CV_HOUGH_GRADIENT, 1, srcGray.rows/4, 200, thresh > 0 ? thresh : 1, 5); // Draw the circles for(size_t i = 0; i < circles.size(); i++) { cv::Point center(cvRound(circles[i][0]), cvRound(circles[i][1])); int radius = cvRound(circles[i][2]); color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); // draw the circle center cv::circle(srcBGR, center, 3, color, -1, 8, 0); // draw the circle outline cv::circle(srcBGR, center, radius, color, 3, 8, 0); } LOGI("Processing took %0.2f ms.", 1000*((float)cv::getTickCount() - t)/(float)cv::getTickFrequency()); cvtColor(srcBGR, mbgra, CV_BGR2BGRA); /************************************************************************************************/ /// Release Java byte buffer and unlock backing bitmap //env-> ReleasePrimitiveArrayCritical(pSource,source,0); /* * If 0, then JNI should copy the modified array back into the initial Java * array and tell JNI to release its temporary memory buffer. * * */ env-> ReleasePrimitiveArrayCritical(pSource, source, JNI_COMMIT); /* * If JNI_COMMIT, then JNI should copy the modified array back into the * initial array but without releasing the memory. That way, the client code * can transmit the result back to Java while still pursuing its work on the * memory buffer * * */ /* * Get<Primitive>ArrayCritical() and Release<Primitive>ArrayCritical() * are similar to Get<Primitive>ArrayElements() and Release<Primitive>ArrayElements() * but are only available to provide a direct access to the target array * (instead of a copy). In exchange, the caller must not perform blocking * or JNI calls and should not hold the array for a long time * */ if (AndroidBitmap_unlockPixels(env, pTarget) < 0) abort(); }
int main_center_of_mass(int argc, char* argv[]){ char* file = "contours.png"; int thresh = 100; //src.convertTo(src_gray,CV_8U); while(true){ cv::Mat src = cv::imread(file); cv::Mat src_gray;// = cv::imread(file,0); cv::cvtColor(src,src_gray,CV_RGB2GRAY); cv::dilate( src_gray, src_gray, cv::Mat() ); cv::erode( src_gray, src_gray, cv::Mat() ); //cv::threshold(src,src_gray,0.5,255,CV_THRESH_BINARY); cv::Mat1b src_g; cv::cvtColor(src,src_g,CV_RGB2GRAY); cv::Mat canny_output; cv::vector<cv::vector<cv::Point> > contours; cv::vector<cv::Vec4i> hierarchy; /// Detect edges using canny cv::Canny( src_gray, canny_output, thresh, thresh*2, 3 ); cv::imshow("canny",canny_output); /// Find contours cv::findContours( canny_output, contours, hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) ); cv::Mat drawing = cv::Mat::zeros( canny_output.size(), CV_8UC3 ); int idx = 0; int max = -1; for(unsigned int i = 0; i< contours.size(); i++ ){ cv::Scalar color3 = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); drawContours( drawing, contours, i, color3, 2, 8, hierarchy, 0, cv::Point() ); int coiso = contours.at(i).size(); if(coiso > max){ idx = i; max = coiso; } } cv::Moments mm = moments( contours[idx], false ); cv::Point2f center = cv::Point2f((float)(mm.m10/mm.m00) , (float)(mm.m01/mm.m00)); cv::Rect rect = cv::boundingRect(cv::Mat(contours[idx])); for(unsigned int i = rect.y ; i < rect.y + rect.height; i++){ for(unsigned int j = rect.x ; j < rect.x + rect.width ; j++){ cv::Scalar color2 = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); if(src_gray.ptr<unsigned char>(i)[j]){ drawing.ptr<unsigned char>(i)[3*j] = (unsigned char)color2.val[0]; // first channel drawing.ptr<unsigned char>(i)[3*j+1]= (unsigned char)color2.val[1]; // second channel drawing.ptr<unsigned char>(i)[3*j+2]= (unsigned char)color2.val[2]; // third channel //cv::circle( drawing, pt, 1, color2, -1, 2, 0 ); } } } cv::Scalar color = cv::Scalar( 255, 255, 255 ); drawContours( drawing, contours, idx, color, 2, 8, hierarchy, 0, cv::Point() ); cv::circle( drawing, center, 4, color, -1, 8, 0 ); cv::rectangle(src,rect,color); /* /// Get the moments cv::vector<cv::Moments> mu(contours.size() ); for( int i = 0; i < contours.size(); i++ ) { mu[i] = moments( contours[i], false ); } /// Get the mass centers: cv::vector<cv::Point2f> mc( contours.size() ); for( int i = 0; i < contours.size(); i++ ) { mc[i] = cv::Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); } cv::Mat drawing = cv::Mat::zeros( canny_output.size(), CV_8UC3 ); cv::Scalar color = cv::Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); drawContours( drawing, contours, idx, color, 2, 8, hierarchy, 0, cv::Point() ); cv::circle( src, mc[idx], 4, color, -1, 8, 0 );*/ cv::imshow("src2",src); cv::imshow("cont",drawing); cv::waitKey(22); } return 0; }
PERF_TEST_P(Size_Dp_MinDist, OCL_HoughCircles, testing::Combine( testing::Values(perf::sz720p, perf::szSXGA, perf::sz1080p), testing::Values(1.0f, 2.0f, 4.0f), testing::Values(1.0f, 10.0f))) { const cv::Size size = std::tr1::get<0>(GetParam()); const float dp = std::tr1::get<1>(GetParam()); const float minDist = std::tr1::get<2>(GetParam()); const int minRadius = 10; const int maxRadius = 30; const int cannyThreshold = 100; const int votesThreshold = 15; cv::RNG rng(123456789); cv::Mat src(size, CV_8UC1, cv::Scalar::all(0)); const int numCircles = rng.uniform(50, 100); for (int i = 0; i < numCircles; ++i) { cv::Point center(rng.uniform(0, src.cols), rng.uniform(0, src.rows)); const int radius = rng.uniform(minRadius, maxRadius + 1); cv::circle(src, center, radius, cv::Scalar::all(255), -1); } cv::ocl::oclMat ocl_src(src); cv::ocl::oclMat ocl_circles;
Mat randomMat(Size size, int type, double minVal, double maxVal, bool useRoi = false) { RNG dataRng(rng.next()); return cvtest::randomMat(dataRng, size, type, minVal, maxVal, useRoi); }
void Controller::generate_model(){ //Create Average images; //this->_model_depth_average = cv::Mat::zeros(cv::Size(640,480),CV_16UC1); //this->_model_color_average = cv::Mat::zeros(cv::Size(640,480),CV_8UC3); //cv::Mat average_counter = cv::Mat::zeros(cv::Size(640,480),CV_8UC1); int old_step = this->_property_manager->_3d_step; cv::Mat1i freq_n(cv::Size(640,480),0); cv::Mat1f freq_v(cv::Size(640,480),0); cv::Mat freq_c = cv::Mat::zeros(cv::Size(640,480),CV_32FC3); int idx, idx_clr; float* ptr_freq_v = (float*)freq_v.data; int* ptr_freq_n = (int*)freq_n.data; float* ptr_freq_c = (float*)freq_c.data; //Create Depth and Color Sum Image for(int k = 0 ; k < this->_model_frames_depth.size() ; ++k){ UINT16* ptr_16u = (UINT16*)this->_model_frames_depth[k].data; uint8_t* ptr_clr = (uint8_t*)this->_model_frames_color[k].data; for(int y = 0; y < XN_VGA_Y_RES ; ++y) { for(int x = 0; x < XN_VGA_X_RES ; ++x) { idx = y * XN_VGA_X_RES + x; if(ptr_16u[idx]){ ptr_freq_n[idx]++; ptr_freq_v[idx]+=ptr_16u[idx]; } idx_clr = y * XN_VGA_X_RES * 3 + x* 3; ptr_freq_c[idx_clr + 0] += ptr_clr[idx_clr + 0]; ptr_freq_c[idx_clr + 1] += ptr_clr[idx_clr + 1]; ptr_freq_c[idx_clr + 2] += ptr_clr[idx_clr + 2]; } } } //Create Depth and Color Average Image for(int y = 0; y < XN_VGA_Y_RES ; ++y) { for(int x = 0; x < XN_VGA_X_RES ; ++x) { idx = y * XN_VGA_X_RES + x; if(ptr_freq_n[idx]){ ptr_freq_v[idx] /= ptr_freq_n[idx]; } } } freq_c /= this->_model_frames_color.size(); freq_c.convertTo(this->_model_color_average,CV_8UC3); freq_v.convertTo(this->_model_depth_average,CV_16UC1); //cv::Mat t8u; //this->_model_depth_average.convertTo(t8u,CV_8UC1,0.05); //cv::imshow("win1",this->_model_color_average); ////cv::imshow("win2",this->_mat_color_bgr); //cv::imshow("win3",t8u); //cv::imshow("win4",this->_mat_depth8UC1); //cv::waitKey(); //Create Masks for avg images cv::Mat main_mask; cv::inRange(this->_model_depth_average, this->_property_manager->_depth_min, this->_property_manager->_depth_max, main_mask); cv::bitwise_and(main_mask,this->_mask_mirrors_and_foor,main_mask); //Contours to remove noise cv::Mat t8u; main_mask.convertTo(t8u,CV_8UC1,0.05); //cv::Mat image_temp; //this->_model_depth_average.copyTo(image_temp); cv::vector<cv::vector<cv::Point> > contours; cv::vector<cv::Vec4i> hierarchy; cv::findContours( t8u, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0) ); for(unsigned int i = 0; i< contours.size(); i++ ){ if(contours[i].size() < 50){ cv::Scalar clr = cv::Scalar(/*255);// */rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) ); cv::Rect rect = cv::boundingRect(contours[i]); drawContours( this->_model_color_average, contours, i, clr, -1, 8, hierarchy, 0, cv::Point() ); //cv::rectangle(top_view_color,rect, clr); } } Mirror* mirror; uchar* ptr_mirror_mask = this->_mask_mirrors.data; //Generate 3D this->_model_n_points; uchar* ptr_main_mask = main_mask.data; //uchar* ptr_mirror_mask = this->_mask_mirrors.data; UINT16* ptr_16u = (UINT16*)this->_model_depth_average.data; for(int y = 0; y < XN_VGA_Y_RES ; ++y /*y += this->_property_manager->_3d_step*/) { for(int x = 0; x < XN_VGA_X_RES ; ++x/*x += this->_property_manager->_3d_step*/) { idx = y * XN_VGA_X_RES + x; if(ptr_main_mask[idx]){ XnPoint3D point1; point1.X = x; point1.Y = y; point1.Z = ptr_16u[idx]; if(ptr_mirror_mask[idx]){ for(int j = 0 ; j < this->_mirrors.size() ; ++j){ mirror = this->_mirrors[j]; if(mirror && mirror->_area_mask.data[idx]){ if(point1.Z > mirror->_depth_min && point1.Z < mirror->_depth_max){ this->_model_back_3d_to_2d[this->_model_n_points][XX] = x; this->_model_back_3d_to_2d[this->_model_n_points][YY] = y; this->_model_projective[this->_model_n_points++] = point1; } } } } else{ this->_model_back_3d_to_2d[this->_model_n_points][XX] = x; this->_model_back_3d_to_2d[this->_model_n_points][YY] = y; this->_model_projective[this->_model_n_points++] = point1; } } } } bool result = this->_kinect->convert_to_realworld( this->_model_n_points, this->_model_projective, this->_model_realworld); //uint8_t* ptr_clr = (uint8_t*)this->_model_color_average.data; //Generate PCL-3D Floor //uchar* ptr_mask_floor = mask_floor.data; //for(int y = 0; y < XN_VGA_Y_RES ; y += this->_property_manager->_3d_step) { // for(int x = 0; x < XN_VGA_X_RES ; x += this->_property_manager->_3d_step) { // //if(ptr_mask_floor[y * XN_VGA_X_RES + x]){ // //} // } //} //Generate PCL-3D from Mirrors _pcl_cloud.clear(); uchar* ptr = this->_mask_main.data; uint8_t* ptr_clr = (uint8_t*)this->_model_color_average.data; _model_cloud.clear(); int xx, yy; double dist; std::vector<double> nx,ny,nz; for(int i = 0 ; i < this->_mirrors.size() ; ++i){ double nx_,ny_,nz_; mirror = this->_mirrors[i]; if(mirror){ mirror->_n_points = 0; mirror->_plane.get_normal(&nx_,&ny_,&nz_); nx_ *= -1; ny_ *= -1; nz_ *= -1; nx.push_back(nx_); ny.push_back(ny_); nz.push_back(nz_); } } for(int i = 0 ; i < this->_model_n_points ; ++i){ xx = this->_model_back_3d_to_2d[i][XX]; yy = this->_model_back_3d_to_2d[i][YY]; idx = yy * XN_VGA_X_RES + xx; if(ptr_mirror_mask[idx]){ for(int j = 0 ; j < this->_mirrors.size() ; ++j){ mirror = this->_mirrors[j]; if(mirror && mirror->_area_mask.data[idx]){ //if(this->_model_realworld[i].Z > mirror->_depth_min && this->_model_realworld[i].Z < mirror->_depth_max){ dist = mirror->_plane.distance_to_plane( this->_model_realworld[i].X, this->_model_realworld[i].Y, this->_model_realworld[i].Z); this->_model_realworld[i].X += 2 * dist * nx[j]; this->_model_realworld[i].Y += 2 * dist * ny[j]; this->_model_realworld[i].Z += 2 * dist * nz[j]; //} } } } dist = this->_floor->_plane.distance_to_plane( this->_model_realworld[i].X, this->_model_realworld[i].Y, this->_model_realworld[i].Z); if(dist > this->_floor->_thresh){ pcl::PointXYZRGB pt(ptr_clr[yy * XN_VGA_X_RES * 3 + xx* 3 + 2], ptr_clr[yy * XN_VGA_X_RES * 3 + xx* 3 + 1], ptr_clr[yy * XN_VGA_X_RES * 3 + xx* 3 + 0]); pt.x = this->_model_realworld[i].X; pt.y = this->_model_realworld[i].Y; pt.z = this->_model_realworld[i].Z; this->_model_cloud.push_back(pt); } } this->_property_manager->_3d_step = old_step; this->_property_manager->_flag_processed[PropertyManager::P_CAPTURE_SHOW] = true; }
double randomDouble(double minVal, double maxVal) { return rng.uniform(minVal, maxVal); }
static cv::Scalar randomScalar() { static cv::RNG rng(12345); return cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)); }
void extractPatch(cv::Mat &img, int *hull, int bbW, int bbH, unsigned char filledColor, cv::RNG &rng, double noise, double angle, double shift, double scale, cv::Mat & noiseM, cv::Mat &result) { int cpX = (hull[0] + hull[2]) / 2; int cpY = (hull[1] + hull[3]) / 2; cv::Mat h = cv::Mat::eye(3, 3, CV_64FC1); cv::Mat temp = cv::Mat::eye(3, 3, CV_64FC1); double *tempPtr = temp.ptr<double>(); double sc; double ang, ca, sa; double shR, shC; double xMin, yMin, xMax, yMax; unsigned char *resPtr; double *noisePtr; int size; //****Translating... shR = shift * bbH * (rng.uniform(1e-4, 1.)-0.5); shC = shift * bbW * (rng.uniform(1e-4, 1.)-0.5); *(tempPtr + 2) = shC; *(tempPtr + temp.cols + 2) = shR; h *= temp; //Reset... *(tempPtr + 2) = 0.0; *(tempPtr + temp.cols + 2) = 0.0; //****Rotating... ang = 2 * CV_PI / 360.0 * angle * (rng.uniform(1e-4, 1.)-0.5); ca = cos(ang); sa = sin(ang); *tempPtr = ca; *(tempPtr + 1) = -sa; *(tempPtr + temp.cols) = sa; *(tempPtr + temp.cols + 1) = ca; h *= temp; //Reset... *tempPtr = 1.0; *(tempPtr + 1) = 0.0; *(tempPtr + temp.cols) = 0.0; *(tempPtr + temp.cols + 1) = 1.0; //****Scaling... sc = 1.0 - scale*(rng.uniform(1e-4, 1.)-0.5); *tempPtr = (double)sc; *(tempPtr + temp.cols + 1) = (double)sc; h *= temp; //Reset... *tempPtr = 1.0; *(tempPtr + temp.cols + 1) = 1.0; //****Shifting Center of BB to (0, 0)... *(tempPtr + 2) = -cpX; *(tempPtr + temp.cols + 2) = -cpY; h *= temp; //Now Warp the Patch... bbW--; bbH--; xMin = -bbW / 2.0; yMin = -bbH / 2.0; xMax = bbW / 2.0; yMax = bbH / 2.0; warpImageROI(img, xMin, yMin, xMax, yMax, bbW, bbH, h, filledColor, result.data); //Add Random Noise... rng.fill(noiseM, cv::RNG::NORMAL, cv::Mat::zeros(1,1,CV_64FC1), cv::Mat::ones(1,1,CV_64FC1)); noiseM *= noise; //Here OpenCV Applies Saturation Arithmetic by Itself... cv::add(result, noise, result, cv::noArray(), CV_8UC1); }
int randomInt(int minVal, int maxVal) { return rng.uniform(minVal, maxVal); }
/** * Detect people using background segmentation and contours * BSN2013 */ static vector<cv::Mat> detectPeopleSegment(cv::Mat image) { vector<cv::Mat> points; // convert to HSV cv::Mat imageHSV; cv::cvtColor(image, imageHSV, CV_BGR2HSV); vector<cv::Mat> imageHSVSlices; cv::split(imageHSV, imageHSVSlices); //cv::threshold(imageHSVSlices[0], imageHSVSlices[0], 160, 200, cv::THRESH_BINARY); // background subtraction cv::Mat fgMask; bgmodel(image, fgMask, learningRate); // tidy foreground mask cv::GaussianBlur(fgMask, fgMask, cv::Size(1, 1), 0, 0); int erosionSize = 5; cv::Mat element = cv::getStructuringElement( cv::MORPH_ELLIPSE, cv::Size(2*erosionSize+1, 2*erosionSize+1), cv::Point( erosionSize, erosionSize )); cv::dilate(fgMask, fgMask, element); cv::erode(fgMask, fgMask, element); cv::erode(fgMask, fgMask, element); cv::dilate(fgMask, fgMask, element); cv::Mat background; bgmodel.getBackgroundImage(background); //cv::imshow("back", background); // subtract background from original image cv::Mat foreground; //cv::not cv::threshold(fgMask, fgMask, 128, 255, cv::THRESH_BINARY); image.copyTo(foreground, fgMask); cv::imshow("fg", fgMask); cv::imshow("fore", foreground); // edge information int lowThreshold = 100; int ratio = 3; int kernelSize = 3; cv::Mat imageCanny; cv::Canny(foreground, imageCanny, lowThreshold, lowThreshold*ratio, kernelSize); // weight map and weighted-gradient image // apply Gaussian filter (size = 9 and sigma = 1.5) to edge information from foreground image // create Gaussian filter // weight map cv::Mat weightMap; cv::GaussianBlur(imageCanny, weightMap, cv::Size(9, 9), 1.5, 1.5); // gradient image cv::Mat imageGray; cv::cvtColor(image, imageGray, CV_BGR2GRAY); cv::Mat imageGradient; cv::Mat imageGradientX; cv::Mat imageGradientY; cv::Mat imageAbsGradientX; cv::Mat imageAbsGradientY; cv::Sobel(imageGray, imageGradientX, CV_16S, 1, 0, 3, 1, 0, cv::BORDER_DEFAULT); cv::Sobel(imageGray, imageGradientY, CV_16S, 0, 1, 3, 1, 0, cv::BORDER_DEFAULT); cv::convertScaleAbs(imageGradientX, imageAbsGradientX); cv::convertScaleAbs(imageGradientY, imageAbsGradientY); cv::addWeighted(imageAbsGradientX, 0.5, imageAbsGradientY, 0.5, 0, imageGradient); // weighted-gradient image cv::Mat weightedGradient; cv::Mat colourWeightMap; weightedGradient = imageGradient.mul(weightMap); // object (body) contours vector< vector<cv::Point> > objectContours; vector<cv::Vec4i> objectHierarchy; cv::findContours(fgMask, objectContours, objectHierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0)); // bodies and heads // store index of detected body contours and position of head vector<int> bodies; vector<cv::Point2f> headCenter; vector<float> headRadius; // detect big bodies for (int i = 0; i < objectContours.size(); i++) { // if contour is too big if (getContourRadius(objectContours[i]) > BODYSIZE*2) { // increment merged counter numMerged++; cout << "Merged object" << endl; // TODO cut down to size // TODO consider just slicing it // process contour by eroding it cv::Mat largeContour = cv::Mat::zeros(imageCanny.size(), CV_8UC3); drawContours(largeContour, objectContours, i, colourRed, CV_FILLED, 8, objectHierarchy, 0, cv::Point()); // erode until large contour becomes 2+ vector< vector<cv::Point> > largeContours; vector<cv::Vec4i> largeHierarchy; do { cv::erode(largeContour, largeContour, element); cv::Canny(largeContour, largeContour, lowThreshold, lowThreshold*ratio, kernelSize); cv::findContours(largeContour, largeContours, largeHierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0)); } while (largeContours.size() == 1); // || (largeContours.size() == 1 && getContourRadius(largeContours[0]) >= BODYSIZE)); // TODO potential infinite bug here if (largeContours.size() > 1) { // increment split counter numSplit++; cout << "Split object" << endl; } else if (largeContours.size() == 1) { // increment unsplit counter numUnsplit++; cout << "No split - size still 1" << endl; } for (int j = 0; j < largeContours.size(); j++) { objectContours.push_back(largeContours[j]); } } } cv::Mat bodiesHeads = cv::Mat::zeros(image.size(), CV_8UC3); // detect bodies for (int i = 0; i < objectContours.size(); i++) { if (isBody(objectContours[i])) { // predict head position cv::Point2f defaultHeadCenter; // body bounding box cv::RotatedRect minBodyRect; minBodyRect = cv::minAreaRect(cv::Mat(objectContours[i])); // body bounding circle radius float headOffset = getContourRadius(objectContours[i]); //*0.7; // image centre cv::Point2f imageCentre(image.size().width/2, image.size().height/2); // find gradient float m = (minBodyRect.center.y - imageCentre.y)/(minBodyRect.center.x - imageCentre.x); // find angle double angle; if (minBodyRect.center.x <= imageCentre.x && minBodyRect.center.y < imageCentre.y) { // top left quad angle = atan((imageCentre.x - minBodyRect.center.x)/(imageCentre.y - minBodyRect.center.y)); } else if (minBodyRect.center.x <= imageCentre.x) { // bottom left quad angle = PI - atan((imageCentre.x - minBodyRect.center.x)/(minBodyRect.center.y - imageCentre.y)); } else if (minBodyRect.center.x > imageCentre.x && minBodyRect.center.y > imageCentre.y) { // bottom right quad angle = PI + atan((minBodyRect.center.x - imageCentre.x)/(minBodyRect.center.y - imageCentre.y)); } else { // top right quad angle = 2*PI - atan((minBodyRect.center.x - imageCentre.x)/(imageCentre.y - minBodyRect.center.y)); } do { headOffset *= 0.7; defaultHeadCenter = cv::Point2f(minBodyRect.center.x - headOffset * sin(angle), minBodyRect.center.y - headOffset * cos(angle)); } while (cv::pointPolygonTest(objectContours[i], defaultHeadCenter, true) <= 0 && headOffset >= 1); // store body and head if body big enough for head if (headOffset >= 1) { // store body bodies.push_back(i); //angle = angle * 180/PI; headCenter.push_back(defaultHeadCenter); headRadius.push_back(0); // default head size // get detailed contours of body cv::Mat bodyMask = cv::Mat::zeros(image.size(), CV_8UC1); drawContours(bodyMask, objectContours, i, colourWhite, CV_FILLED, 8, objectHierarchy, 0, cv::Point()); //cv::floodFill(bodyMask, cv::Point2i(0, 0), cv::Scalar(1)); cv::Mat body; image.copyTo(body, bodyMask); //cv::imshow("B", body); // body edges cv::Mat bodyCanny; cv::Canny(body, bodyCanny, lowThreshold, lowThreshold*ratio, kernelSize); // weight map cv::Mat bodyWeightMap; cv::GaussianBlur(bodyCanny, bodyWeightMap, cv::Size(9, 9), 1.5, 1.5); // gradient image cv::Mat bodyGray; cv::cvtColor(body, bodyGray, CV_BGR2GRAY); cv::Mat bodyGradient; cv::Mat bodyGradientX; cv::Mat bodyGradientY; cv::Mat bodyAbsGradientX; cv::Mat bodyAbsGradientY; cv::Sobel(bodyGray, bodyGradientX, CV_16S, 1, 0, 3, 1, 0, cv::BORDER_DEFAULT); cv::Sobel(bodyGray, bodyGradientY, CV_16S, 0, 1, 3, 1, 0, cv::BORDER_DEFAULT); cv::convertScaleAbs(bodyGradientX, bodyAbsGradientX); cv::convertScaleAbs(bodyGradientY, bodyAbsGradientY); cv::addWeighted(bodyAbsGradientX, 0.5, bodyAbsGradientY, 0.5, 0, bodyGradient); // weighted-gradient image cv::Mat bodyWeightedGradient; bodyWeightedGradient = bodyGradient.mul(bodyWeightMap); // body contours vector< vector<cv::Point> > bodyContours; vector<cv::Vec4i> bodyHierarchy; cv::findContours(bodyWeightedGradient, bodyContours, bodyHierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0)); // detect head for (int j = 0; j < bodyContours.size(); j++) { // process contour by eroding it cv::Mat aContour = cv::Mat::zeros(image.size(), CV_8UC3); drawContours(aContour, bodyContours, j, colourWhite, CV_FILLED, 8, bodyHierarchy, 0, cv::Point()); drawContours(bodiesHeads, bodyContours, j, colourWhite, 2, 8, bodyHierarchy, 0, cv::Point()); cv::erode(aContour, aContour, element); //cv::erode(aContour, aContour, element); //cv::dilate(aContour, aContour, element); cv::Canny(aContour, aContour, lowThreshold, lowThreshold*ratio, kernelSize); vector< vector<cv::Point> > subContours; vector<cv::Vec4i> subHierarchy; cv::findContours(aContour, subContours, subHierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0)); // for (int k = 0; k < subContours.size(); k++) { //cv::drawContours(imageContours, subContours, k, cv::Scalar(0, 255, 0), 2, 8, subHierarchy, 0, cv::Point()); if (isHead(subContours[k], objectContours[i])) { vector<cv::Point> contourPoly; cv::Point2f center; float radius; if (subContours.size() > 1) { approxPolyDP(cv::Mat(subContours[k]), contourPoly, 3, true); } else { approxPolyDP(cv::Mat(bodyContours[j]), contourPoly, 3, true); } minEnclosingCircle((cv::Mat)contourPoly, center, radius); float distanceOld = euclideanDistance(headCenter[headCenter.size() - 1], defaultHeadCenter); float distanceNew = euclideanDistance(center, defaultHeadCenter); if (headRadius[headRadius.size() - 1] == 0 || (distanceOld > 0 && distanceNew < distanceOld)) { // store first detected head or store if it is a better detection headCenter[headCenter.size() - 1] = center; headRadius[headRadius.size() - 1] = radius; } } } } if (headRadius[headRadius.size() - 1] == 0) { headRadius[headRadius.size() - 1] = 10; } } } } // draw bodies and heads //cv::Mat bodiesHeads = cv::Mat::zeros(image.size(), CV_8UC3); for (int i = 0; i < bodies.size(); i++) { // draw body cv::Scalar colour = cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)); drawContours(foreground, objectContours, bodies[i], colour, 2, 8, objectHierarchy, 0, cv::Point()); circle(foreground, headCenter[i], (int)headRadius[i], colour, 2, 8, 0); // body bounding box cv::RotatedRect bodyRect; bodyRect = cv::minAreaRect(cv::Mat(objectContours[bodies[i]])); // output cout << imageNum; cout << "," << headCenter[i].x << "," << headCenter[i].y << "," << headRadius[i]; // head info cout << "," << bodyRect.center.x << "," << bodyRect.center.y; cout << "," << cv::contourArea(objectContours[bodies[i]]); cout << endl; // output points cv::Mat point(2, 1, CV_32FC1); point.at<float>(0) = headCenter[i].x; point.at<float>(1) = headCenter[i].y; points.push_back(point); } // increment frame counter numFrames++; cv::imshow("Original", image); //cv::imshow("Hue", imageHSVSlices[0]); //cv::imshow("Saturation", imageHSVSlices[1]); //cv::imshow("Value", imageHSVSlices[2]); cv::imshow("fgMask", fgMask); cv::imshow("Foreground", foreground); cv::imshow("Canny", imageCanny); cv::imshow("WeightMap", weightMap); cv::imshow("Gradient Image", imageGradient); cv::imshow("Weighted-Gradient Image", weightedGradient); //cv::imshow("Contours", imageContours); cv::imshow("Body & Head", bodiesHeads); cvWaitKey(delay); //5 return points; }