Bleb::Bleb(vector<Point> &bunch, Point2f ¢roid, int &BIN) { //bleb size size = bunch.size(); //bleb center vector<Point> hull; convexHull(bunch, hull); Moments mu = moments(hull); Point2f blebCtr = Point2f(mu.m10/mu.m00, mu.m01/mu.m00); center.x = blebCtr.x; center.y = blebCtr.y; // bleb bunch in polar coordinates double theta = 0; for(unsigned int n = 0; n < bunch.size(); n++){ polarPoint pt = cartesianToPolar1(bunch[n], centroid); bunch_polar.push_back(pt); theta += pt.theta; } theta /= bunch.size(); bin = theta/(3.1415926*2/BIN)+BIN/2; // bleb bounding ellipse roughArea = fitEllipse(Mat(bunch)); }
void CvMSER::onNewImage() { LOG(LTRACE) << "CvMSER::onNewImage\n"; try { // img: a RGB image. cv::Mat img = in_img.read(); cv::Mat yuv,gray; cvtColor(img,yuv, COLOR_BGR2YCrCb); cvtColor(img, gray, COLOR_BGR2GRAY); vector<vector<Point> > regions; cv::MSER ms; ms(img, regions, cv::Mat()); for (int i = 0; i < regions.size(); i++) { ellipse(img, fitEllipse(regions[i]), Scalar(255)); } // Write contours to the output. out_contours.write(regions); out_img.write(img); } catch (...) { LOG(LERROR) << "CvMSER::onNewImage failed\n"; } }
void BallDetector::contourDetection() { Canny(thrs,cannyImg, 50, 150, 3); vector<vector<Point> > contours; vector<Vec4i> hierarchy; findContours(cannyImg, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE, Point(0,0)); vector<RotatedRect> minRect(contours.size()); vector<Point2f> center(contours.size()); vector<float> radius(contours.size()); for( size_t i = 0; i < contours.size(); i++) { if(contours[i].size() > 5) minRect[i] = fitEllipse(Mat(contours[i])); minEnclosingCircle(contours[i],center[i],radius[i]); } RNG rng(12345); Mat drawing = Mat::zeros(cannyImg.size(),CV_8UC3); for( size_t i = 0; i < contours.size(); i++) { Scalar color = Scalar(rng.uniform(0,255),rng.uniform(0,255),rng.uniform(0,255)); Size2f s = minRect[i].size; Point2f c = minRect[i].center; if(contours[i].size() > 5 && s.width/s.height > 0.7 && s.width/s.height < 1.4 && s.width > 5 && s.height > 5) // && arcLength(contours[i],true)/(2*CV_PI*radius[i])>0.8 && arcLength(contours[i],true)/(2*CV_PI*radius[i]) < 1.2 ) { drawContours(drawing, contours, (int)i, color, -1, 8, hierarchy, 0, Point()); cout<<c.x<<" "<<c.y<<endl; cout<<s.width<<" "<<s.height<<endl<<endl; } } imshow("contours",drawing); imwrite("images/contours.png",drawing); }
bool ManualLabeling::manualLabelingCallback(cwru_opencv_common::image_label::Request& request, cwru_opencv_common::image_label::Response& response) { // Put sensor_msgs::Image in cv::Mat const sensor_msgs::Image::Ptr &image = boost::make_shared<sensor_msgs::Image>(request.imageQuery); cv::Mat rawImageIn = cv_bridge::toCvShare(image, "bgr8")->image.clone(); // Declare labeled image cv::Mat labeledImage; // Initialize blobs std::vector<cv::Mat> labeledBlobs; labeledBlobs.clear(); // Apply adaptive threshold cv::Mat imgHSV; cv::cvtColor(rawImageIn, imgHSV, CV_BGR2HSV); // create a click window: cv::Point imagePt(-1, -1); cv::namedWindow("Selectable Points"); cv::setMouseCallback("Selectable Points", cv_ui::getCoordinates, &imagePt); int imageCount(0); // fill the blobs. while (true) { int blobCount = (int) floor((double) imageCount / 2.0); int lr = imageCount % 2; // select the points from right side to left side imshow("Selectable Points", rawImageIn); char keyIn = cv::waitKey(50); if (imagePt.x > 0) { cv::Mat labeledBlob; labeledBlob = cv::Mat::zeros(rawImageIn.size(), CV_8UC1); ManualLabeling::growFromSeedRaw(rawImageIn, labeledBlob, imagePt); std::vector<std::vector<cv::Point2i> > contours; cv::Mat hierarchy; findContours(labeledBlob, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE); cv::RotatedRect newRect(fitEllipse(contours[0])); ROS_INFO("Finished point at index %d \n Image side %d \n next point.\n", blobCount, lr); labeledBlobs.push_back(labeledBlob); imageCount++; imagePt.x = -1; } // if the Esc key is pressed, break out. if (keyIn == 27) break; } cv::destroyWindow("Selectable Points"); printf("Finished the catheter display image. \n"); // Merge blob to label image if(labeledBlobs.size() > 0) { merge(labeledBlobs, labeledImage); cv_bridge::CvImage(std_msgs::Header(), "bgr8", labeledImage).toImageMsg(response.imageResp); return true; } else return false; }
//-------------------------------------------------------------- void openniTracking::computeContourAnalysis(){ for (unsigned int i = 0; i < contourFinder.nBlobs; i++){ int length_of_contour = contourFinder.blobs[i].pts.size(); // ellipse fitEllipse(contourFinder.blobs[i].pts, box[i]); // angles blobAngle[i] = getOrientation(contourFinder.blobs[i].pts); // assign smoothed and normalized blobs geometry vectors vars if(computeContourGeometry){ findLines(contourFinder.blobs[i].pts,geomLines[i],30,40,30); _s_blobGeom[i].clear(); _s_blobGeom[i].assign(geomLines[i].size(), ofVec4f()); _osc_blobGeom[i].clear(); _osc_blobGeom[i].assign(geomLines[i].size(), ofVec4f()); } // smoothed, simple and convexHull contours computing contourReg[i].clear(); contourReg[i].assign(length_of_contour, ofVec2f()); contourSmooth[i].clear(); contourSmooth[i].assign(length_of_contour, ofVec2f()); _s_contourSmooth[i].clear(); _s_contourSmooth[i].assign(length_of_contour, ofVec2f()); _osc_contourSmooth[i].clear(); _osc_contourSmooth[i].assign(length_of_contour, ofVec2f()); for(int j = 0; j < length_of_contour; j++){ contourReg[i].at(j) = contourFinder.blobs[i].pts[j]; } contourS.smooth(contourReg[i], contourSmooth[i], smoothPct); contourSimple[i].clear(); contourS.simplify(contourSmooth[i], contourSimple[i], tolerance); _s_contourSimple[i].clear(); _s_contourSimple[i].assign(contourSimple[i].size(), ofVec2f()); _osc_contourSimple[i].clear(); _osc_contourSimple[i].assign(contourSimple[i].size(), ofVec2f()); } }
void MserFeatureDetector::detectImpl(const Mat& image, const Mat& mask, vector<KeyPoint>& keypoints) const { vector<vector<Point> > msers; mser(image, msers, mask); keypoints.resize(msers.size()); vector<vector<Point> >::const_iterator contour_it = msers.begin(); vector<KeyPoint>::iterator keypoint_it = keypoints.begin(); for (; contour_it != msers.end(); ++contour_it, ++keypoint_it) { // TODO check transformation from MSER region to KeyPoint RotatedRect rect = fitEllipse(Mat(*contour_it)); *keypoint_it = KeyPoint(rect.center, sqrt(rect.size.height * rect.size.width), rect.angle); } }
void ShapeFeature::compute(Mat& src) { resultingImage = src; Mat channel[3]; // The actual splitting. split(resultingImage, channel); channel[1].setTo(Scalar(0)); Mat br; merge(channel,3,br); channel[0].setTo(Scalar(0)); Mat r; merge(channel,3,r); cvtColor(r, r, CV_BGR2GRAY); medianBlur(r, r, 9 ); equalizeHist(r, r); threshold(r, r, 120, 255, THRESH_BINARY); erode(r, r, Mat()); dilate(r, r, Mat()); vector< vector <Point> > contours; // Vector for storing contour vector< Vec4i > hierarchy; int largest_contour_index=0; int largest_area=0; findContours( r.clone(), contours, hierarchy,RETR_EXTERNAL, CHAIN_APPROX_SIMPLE ); // Find the contours in the image for( int i = 0; i< contours.size(); i++ ){ double a=contourArea( contours[i],false); // Find the area of contour if(a>largest_area){ largest_area=a; largest_contour_index=i; //Store the index of largest contour } } Mat pointsf; Mat(contours[largest_contour_index]).convertTo(pointsf, CV_32F); RotatedRect boxE = fitEllipse(pointsf); if(boxE.size.width<boxE.size.height) value = (float)boxE.size.width/boxE.size.height; else value = (float)boxE.size.height/boxE.size.width; }
Mat Draw::drawMSERs(const Mat& src, const vector<vector<Point> >& mser_features) { Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3); for (int i = 0; i < mser_features.size(); i++) { Scalar color = CV_RGB( rand()&255, rand()&255, rand()&255 ); for (int j = 0; j < mser_features[i].size(); j++) { circle(dst, mser_features[i][j], 1, color); } ellipse(dst, fitEllipse(mser_features[i]), CV_RGB(255, 0, 0)); } return dst; }
RotatedRect createArenaMask(float x_rad, float y_rad, Mat cameraMatrix, Mat distCoeffs, Mat rvec, Mat tvec) { Point2f center(0, 0); Point3f ellipsePath; vector<Point3f> c3d; vector<Point2f> c2d; RotatedRect ellipseMask; for (double angle = 0; angle <= 2 * CV_PI; angle += 0.001) //You are using radians so you will have to increase by a very small amount { if ( (angle >= 0 && angle < 90) || (angle > 270 && angle <= 360) ) { ellipsePath.x = (x_rad*y_rad) / (sqrt((y_rad*y_rad) + x_rad*x_rad*tan(angle)*tan(angle))); ellipsePath.y = (x_rad*y_rad*tan(angle)) / (sqrt((y_rad*y_rad) + x_rad*x_rad*tan(angle)*tan(angle))); ellipsePath.z = BASE_HEIGHT; c3d.push_back(ellipsePath); } if (angle > 90 && angle < 270) { ellipsePath.x = -(x_rad*y_rad) / (sqrt((y_rad*y_rad) + x_rad*x_rad*tan(angle)*tan(angle))); ellipsePath.y = -(x_rad*y_rad*tan(angle)) / (sqrt((y_rad*y_rad) + x_rad*x_rad*tan(angle)*tan(angle))); ellipsePath.z = BASE_HEIGHT; c3d.push_back(ellipsePath); } } projectPoints(c3d, rvec, tvec, cameraMatrix, distCoeffs, c2d); ellipseMask = fitEllipse(c2d); return ellipseMask; }
cv::RotatedRect fitEllipse(const ofPolyline& polyline) { return fitEllipse(Mat(toCv(polyline))); }
TargetDetector::targetPanel TargetDetector::getSquareBlob(Mat erosion_dst, Mat img_whitebalance, Color::ColorType color ) { //perform blob detection for a square //for now only do blob detection based on area logger.infoStream() << " Finding Contours, Entered getSquareBlob"; vector<vector<Point> > contours; vector<Vec4i> hierarchy; /// Find contours findContours(erosion_dst, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) ); /// Draw contours //Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 ); for( unsigned int i = 0; i< contours.size(); i++ ) { if ((int)contours[i].size() > m_minContourSize) { if (color == Color::RED) drawContours(img_whitebalance, contours, i, Scalar(0,0,255), 2, 8, hierarchy, 0, Point() ); else if (color == Color::GREEN) drawContours(img_whitebalance, contours, i, Scalar(0,255,0), 2, 8, hierarchy, 0, Point() ); else if (color == Color::YELLOW) drawContours(img_whitebalance, contours, i, Scalar(0,255,255), 2, 8, hierarchy, 0, Point() ); else if (color == Color::BLUE) drawContours(img_whitebalance, contours, i, Scalar(255,0,0), 2, 8, hierarchy, 0, Point() ); else drawContours(img_whitebalance, contours, i, Scalar(255,255,0), 2, 8, hierarchy, 0, Point() ); } } //find contour with the largest area- by area I mean number of pixels double maxArea = 0; unsigned int maxContour=0; RotatedRect temp,maxtemp; //targetSmall and targetLarge are within the maxSize contour double area=0.0; double aspectratio=0; //printf("\n number of contours: %d",contours.size()); for(unsigned int j=0; j<contours.size(); j++) { if (contours[j].size() > 6) { temp = minAreaRect(contours[j]); //finds the rectangle that will encompass all the points area = temp.size.width*temp.size.height; aspectratio = temp.size.height/temp.size.width; if (area > maxArea && aspectratio < m_maxAspectRatio && aspectratio > m_minAspectRatio) { maxContour = j; maxtemp = temp; maxArea = area; } } //printf("\n size %d, width %f, height %f area = %f", contours[j].size(), temp.size.width,temp.size.height,area); }; logger.infoStream() << " Max contour area " <<maxArea <<" at " <<maxContour; targetPanel answer; //printf("\n area = %f, maxsize = %d",area,maxsize); if (maxArea < 5) { //unable to find any contours answer.foundLarge = false; answer.foundSmall = false; answer.foundOutline = false; logger.infoStream() << " Unable to find Contours with an area more than 5" ; return(answer); } else { answer.foundOutline = true; logger.infoStream() << "Contours FOund with maxSize = "<<maxContour <<" with area : "<<maxArea; Point2f vertices[4]; maxtemp.points(vertices); //given the vertices find the min and max X and min and maxY double minX= 90000; double maxX = 0; double minY= 90000; double maxY=0; for (int i = 0; i < 4; i++) { //printf("\n verticle = (%f, %f)",vertices[i].x, vertices[i].y); if (vertices[i].x < minX) minX = vertices[i].x; if (vertices[i].x > maxX) maxX = vertices[i].x; if (vertices[i].y < minY) minY = vertices[i].y; if (vertices[i].y > maxY) maxY = vertices[i].y; }; RotatedRect minEllipse; RotatedRect targetLarge; RotatedRect targetSmall; double targetLargeArea = 0; double targetSmallArea = 0; for(unsigned int j=0; j<contours.size(); j++) { if (j != maxContour && (int(contours[j].size()) > m_minSize)) { //make sure the center of the next contour is within the bouding area //have the center, height and width minEllipse = fitEllipse( Mat(contours[j])); //finds the rectangle that will encompass all the points //printf("\n center = (%f,%f), Xrange = %f,%f, Yrange = %f,%f",minEllipse.center.x,minEllipse.center.y,minX,maxX,minY,maxY); if (minEllipse.center.x > minX && minEllipse.center.x < maxX && minEllipse.center.y < maxY && minEllipse.center.y >minY) { //in the middle, therefore save //should also be roughly circular - width should be about equal to height aspectratio = minEllipse.size.height/minEllipse.size.width; if (minEllipse.size.height*minEllipse.size.width > targetLargeArea)// && aspectratio < m_maxAspectRatio && aspectratio > m_minAspectRatio) { //before we go over the large one, save the previous large one to the small one targetSmall = targetLarge; targetSmallArea = targetLargeArea; targetLarge = minEllipse; targetLargeArea = minEllipse.size.height*minEllipse.size.width; } else if (minEllipse.size.height*minEllipse.size.width > targetSmallArea) { targetSmall = minEllipse; targetSmallArea = minEllipse.size.height*minEllipse.size.width; } }//end if in the center } //end if j!=maxcounter }; logger.infoStream() << " TargetLareArea = " <<targetLargeArea <<" Small Area "<<targetSmallArea; //imshow("internal",img_whitebalance); //Display Purposes maxtemp.points(vertices); for (int i = 0; i < 4; i++) { if (color == Color::RED) { line(img_whitebalance, vertices[i], vertices[(i+1)%4], Scalar(0,0,255),12); } else if (color == Color::GREEN) { line(img_whitebalance, vertices[i], vertices[(i+1)%4], Scalar(0,255,0),12); } else if (color == Color::BLUE) { line(img_whitebalance, vertices[i], vertices[(i+1)%4], Scalar(255,0,0),12); } else if (color == Color::YELLOW) { line(img_whitebalance, vertices[i], vertices[(i+1)%4], Scalar(0,255,255),12); } else { line(img_whitebalance, vertices[i], vertices[(i+1)%4], Scalar(255,255,0),12); } } if (targetLargeArea > 0) answer.foundLarge = true; else answer.foundLarge = false; if (targetSmallArea > 0) answer.foundSmall = true; else answer.foundSmall = false; answer.outline = maxtemp; answer.targetSmall = targetSmall; answer.targetLarge = targetLarge; logger.infoStream() << "Sending data: found outline = " <<answer.foundOutline <<" TargetLarge "<<answer.foundLarge << "Target Smaller "<< answer.foundSmall; return(answer); }//end able to find contours answer.foundLarge = false; answer.foundSmall = false; answer.foundOutline = false; return(answer); };
/******************************************************************************* * Function: extractFGTargets * Description: extract FG targets with given conditions and return objects * Arguments: inImg - input image fgImg - output FG mask image seLength - length of structuring elements (opening) threshVal - threshold value for converting to binary image minArea - minimum area of FG targets maxArea - maximum area of FG targets minAspRatio - minimum aspect ratio of FG targets maxAspRatio - maximum aspect ratio of FG targets * Returns: vector<FGObject>* - all extracted FG targets * Comments: * Revision: *******************************************************************************/ vector<FGObject>* FGExtraction::extractFGTargets(InputArray inImg, OutputArray fgImg, int seLength, int threshVal, double minArea, double maxArea, double minAspRatio, double maxAspRatio) { double theta = 0.4; if(!inImg.obj) return NULL; _inImg = inImg.getMat(); this->init(); //showImage("inImg", _inImg); // background subtraction by opening int err = subtractBGOpenDiagonal(inImg, _bgsImg, threshVal, seLength); if (err>0) { vector<FGObject>* fgObjects = new vector<FGObject>; return fgObjects; } //subtractBGMedian(inImg.getMat(), bgSubImg, threshVal, seLength); //showImage("inImg", _inImg, 0, 1); //showImage("bgSub", _bgsImg); // get the contour vector<vector<Point>> contours = extractContours(_bgsImg); //cout<<contours.size()<<endl; // double local thresholding // histogram backprojection Mat mask = Mat::zeros(_bgsImg.size(), CV_8U); vector<int> areas(contours.size()); int cnt = 0; int argMax = 0; int max_area = 0; for(vector<vector<Point> >::const_iterator it = contours.begin(); it != contours.end(); ++it){ Rect uprightBox = boundingRect(*it); areas[cnt] = uprightBox.height*uprightBox.width; if (areas[cnt]>max_area) { max_area = areas[cnt]; argMax = cnt; } cnt++; } //showImage("inImg", _inImg, 0, 1); vector<Point> largestContour = contours[argMax]; //***** only use the largest contour RotatedRect orientedBox = orientedBoundingBox(largestContour); orientedBox.size.width *= 1.5; orientedBox.size.height *= 1.5; ellipse(mask, orientedBox, Scalar(255), -1); //Rect tempRect = boundingRect(largestContour); //Mat tempImg = mask(tempRect); //imshow("tempImg", tempImg); //imshow("mask", mask); //waitKey(0); // double local thresholding double percentage = 0.8; doubleThresholdByValue(percentage, mask); /*finish = clock(); duration = (double)(finish - start) / (double)CLOCKS_PER_SEC; cout << duration << " sec" << endl; start = clock();*/ // remove noise by a median filter medianBlur(_fgHighImg, _fgHighImg, 3); medianBlur(_fgLowImg, _fgLowImg, 3); //showImage("_fgHighImg", _fgHighImg); //showImage("_fgLowImg", _fgLowImg); /*finish = clock(); duration = (double)(finish - start) / (double)CLOCKS_PER_SEC; cout << duration << " sec" << endl; start = clock();*/ // merge two masks using histogram backprojection //showImage("_fgImg", _fgImg); //showImage("mask", mask); updateByHistBackproject(theta, mask); ellipse(mask, orientedBox, Scalar(0), -1); ellipse(_fgHighImg, orientedBox, Scalar(0), -1); ellipse(_fgLowImg, orientedBox, Scalar(0), -1); //} // thresholding by area and variance #ifdef IMAGE_DOWNSAMPLING int dilateSESize = 3; int erodeSESize = 3; int varThresh = 30; #else int dilateSESize = 7; int erodeSESize = 7; int varThresh = 30; #endif //showImage("fg high", _fgHighImg, 0, 1); //showImage("fg low", _fgLowImg, 0, 1); //showImage("after histbp", _fgImg, 0); thresholdByAreaRatioVar(minArea, maxArea, dilateSESize, erodeSESize, minAspRatio, maxAspRatio, varThresh); //showImage("after area threshold", _fgImg, 0); // post-processing postProcessing(_fgImg, _fgImg); //imshow("_fgImg",_fgImg); //waitKey(0); // fill the holes of the fgImg _fgImg.copyTo(fgImg); floodFill(fgImg, cv::Point(0,0), Scalar(255)); //imshow("fgImg",fgImg); //waitKey(0); bitwise_not(fgImg, fgImg); bitwise_or(fgImg, _fgImg, _fgImg); //imshow("inImg", inImg); //imshow("_fgImg",_fgImg); //waitKey(0); // opening RotatedRect rotatedR = fitEllipse(Mat(largestContour)); float objHeight = min(rotatedR.size.height,rotatedR.size.width); int seSize = int(objHeight/10.0+0.5); Mat se = getStructuringElement(MORPH_ELLIPSE, Size(seSize, seSize)); //***** choose different size according to object height morphologyEx(_fgImg, _fgImg, MORPH_OPEN, se); //imshow("_fgImg",_fgImg); //waitKey(0); // close morphologyEx(_fgImg, _fgImg, MORPH_CLOSE, se); // timer /*clock_t start, finish; double duration = 0.0; start = clock(); finish = clock(); duration = (double)(finish - start) / (double)CLOCKS_PER_SEC; cout << duration << " sec" << endl;*/ thresholdByAreaRatioVar(0.5*minArea, maxArea, 1, 1, minAspRatio, maxAspRatio, 30); // push targets into our vector //Mat largeInImg; #ifdef IMAGE_DOWNSAMPLING resize(_fgImg, _fgImg, Size(), 2, 2, INTER_LINEAR); resize(_inImg, largeInImg, Size(), 2, 2, INTER_LINEAR); #endif //tempImg = _fgImg.clone(); //findContours(tempImg, contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0)); //tempImg.release(); //imshow("_fgImg",_fgImg); //waitKey(0); contours = extractContours(_fgImg); vector<FGObject>* fgObjects = new vector<FGObject>; //Mat mask8U = Mat::zeros(largeInImg.size(), CV_8U); for (size_t i = 0; i < contours.size(); i++){ double area = contourArea(contours[i]); RotatedRect orientedRect = orientedBoundingBox(contours[i]); Point2f points[4]; orientedRect.points(points); /* orientedRect.size.width *= 1.5; orientedRect.size.height *= 1.5; ellipse(mask8U, orientedRect, Scalar(255), -1); int channels[] = {0}; int nbins = 16; const int histSize[] = {nbins}; float range[] = {0, 255}; const float* ranges[] = {range}; Mat hist; cv::calcHist(&largeInImg, 1, channels, mask8U, hist, 1, histSize, ranges); */ // push targets into our vector FGObject* obj = new FGObject; //obj->histogram = hist; obj->setObjectProperties(area, orientedRect.angle, contours[i], points, SOURCE_UNRECTIFIED); if(obj->isPartialOut(_fgImg.cols, _fgImg.rows) == false){ fgObjects->push_back(*obj); } delete obj; //ellipse(mask8U, orientedRect, Scalar(0), -1); } // eliminate artifacts with width of 1 at the border... rectangle(_fgImg, Point(0,0), Point(_fgImg.cols-1, _fgImg.rows-1), Scalar(0)); fgImg.getMatRef() = _fgImg.clone(); return fgObjects; }
//majorAxis and minorAxis is the estimated particle size in px void ProgSortByStatistics::processInprocessInputPrepareSPTH(MetaData &SF, bool trained) { //#define DEBUG PCAMahalanobisAnalyzer tempPcaAnalyzer0; PCAMahalanobisAnalyzer tempPcaAnalyzer1; PCAMahalanobisAnalyzer tempPcaAnalyzer2; PCAMahalanobisAnalyzer tempPcaAnalyzer3; PCAMahalanobisAnalyzer tempPcaAnalyzer4; //Morphology tempPcaAnalyzer0.clear(); //Signal to noise ratio tempPcaAnalyzer1.clear(); tempPcaAnalyzer2.clear(); tempPcaAnalyzer3.clear(); //Histogram analysis, to detect black points and saturated parts tempPcaAnalyzer4.clear(); double sign = 1;//;-1; int numNorm = 3; int numDescriptors0=numNorm; int numDescriptors2=4; int numDescriptors3=11; int numDescriptors4 = 10; MultidimArray<float> v0(numDescriptors0); MultidimArray<float> v2(numDescriptors2); MultidimArray<float> v3(numDescriptors3); MultidimArray<float> v4(numDescriptors4); if (verbose>0) { std::cout << " Sorting particle set by new xmipp method..." << std::endl; } int nr_imgs = SF.size(); if (verbose>0) init_progress_bar(nr_imgs); int c = XMIPP_MAX(1, nr_imgs / 60); int imgno = 0, imgnoPCA=0; bool thereIsEnable=SF.containsLabel(MDL_ENABLED); bool first=true; // We assume that at least there is one particle size_t Xdim, Ydim, Zdim, Ndim; getImageSize(SF,Xdim,Ydim,Zdim,Ndim); //Initialization: MultidimArray<double> nI, modI, tempI, tempM, ROI; MultidimArray<bool> mask; nI.resizeNoCopy(Ydim,Xdim); modI.resizeNoCopy(Ydim,Xdim); tempI.resizeNoCopy(Ydim,Xdim); tempM.resizeNoCopy(Ydim,Xdim); mask.resizeNoCopy(Ydim,Xdim); mask.initConstant(true); MultidimArray<double> autoCorr(2*Ydim,2*Xdim); MultidimArray<double> smallAutoCorr; Histogram1D hist; Matrix2D<double> U,V,temp; Matrix1D<double> D; MultidimArray<int> radial_count; MultidimArray<double> radial_avg; Matrix1D<int> center(2); MultidimArray<int> distance; int dim; center.initZeros(); v0.initZeros(numDescriptors0); v2.initZeros(numDescriptors2); v3.initZeros(numDescriptors3); v4.initZeros(numDescriptors4); ROI.resizeNoCopy(Ydim,Xdim); ROI.setXmippOrigin(); FOR_ALL_ELEMENTS_IN_ARRAY2D(ROI) { double temp = std::sqrt(i*i+j*j); if ( temp < (Xdim/2)) A2D_ELEM(ROI,i,j)= 1; else A2D_ELEM(ROI,i,j)= 0; } Image<double> img; FourierTransformer transformer(FFTW_BACKWARD); FOR_ALL_OBJECTS_IN_METADATA(SF) { if (thereIsEnable) { int enabled; SF.getValue(MDL_ENABLED,enabled,__iter.objId); if ( (enabled==-1) ) { imgno++; continue; } } img.readApplyGeo(SF,__iter.objId); if (targetXdim!=-1 && targetXdim!=XSIZE(img())) selfScaleToSize(LINEAR,img(),targetXdim,targetXdim,1); MultidimArray<double> &mI=img(); mI.setXmippOrigin(); mI.statisticsAdjust(0,1); mask.setXmippOrigin(); //The size of v1 depends on the image size and must be declared here int numDescriptors1 = XSIZE(mI)/2; //=100; MultidimArray<float> v1(numDescriptors1); v1.initZeros(numDescriptors1); double var = 1; normalize(transformer,mI,tempI,modI,0,var,mask); modI.setXmippOrigin(); tempI.setXmippOrigin(); nI = sign*tempI*(modI*modI); tempM = (modI*modI); A1D_ELEM(v0,0) = (tempM*ROI).sum(); int index = 1; var+=2; while (index < numNorm) { normalize(transformer,mI,tempI,modI,0,var,mask); modI.setXmippOrigin(); tempI.setXmippOrigin(); nI += sign*tempI*(modI*modI); tempM += (modI*modI); A1D_ELEM(v0,index) = (tempM*ROI).sum(); index++; var+=2; } nI /= tempM; tempPcaAnalyzer0.addVector(v0); nI=(nI*ROI); auto_correlation_matrix(mI,autoCorr); if (first) { radialAveragePrecomputeDistance(autoCorr, center, distance, dim); first=false; } fastRadialAverage(autoCorr, distance, dim, radial_avg, radial_count); for (int n = 0; n < numDescriptors1; ++n) A1D_ELEM(v1,n)=(float)DIRECT_A1D_ELEM(radial_avg,n); tempPcaAnalyzer1.addVector(v1); #ifdef DEBUG //String name = "000005@Images/Extracted/run_002/extra/BPV_1386.stk"; String name = "000010@Images/Extracted/run_001/extra/KLH_Dataset_I_Training_0028.stk"; //String name = "001160@Images/Extracted/run_001/DefaultFamily5"; std::cout << img.name() << std::endl; if (img.name()==name2) { FileName fpName = "test_1.txt"; mI.write(fpName); fpName = "test_2.txt"; nI.write(fpName); fpName = "test_3.txt"; tempM.write(fpName); fpName = "test_4.txt"; ROI.write(fpName); //exit(1); } #endif nI.binarize(0); int im = labelImage2D(nI,nI,8); compute_hist(nI, hist, 0, im, im+1); size_t l; int k,i,j; hist.maxIndex(l,k,i,j); A1D_ELEM(hist,j)=0; hist.maxIndex(l,k,i,j); nI.binarizeRange(j-1,j+1); double x0=0,y0=0,majorAxis=0,minorAxis=0,ellipAng=0; size_t area=0; fitEllipse(nI,x0,y0,majorAxis,minorAxis,ellipAng,area); A1D_ELEM(v2,0)=majorAxis/((img().xdim) ); A1D_ELEM(v2,1)=minorAxis/((img().xdim) ); A1D_ELEM(v2,2)= (fabs((img().xdim)/2-x0)+fabs((img().ydim)/2-y0))/((img().xdim)/2); A1D_ELEM(v2,3)=area/( (double)((img().xdim)/2)*((img().ydim)/2) ); for (int n=0 ; n < numDescriptors2 ; n++) { if ( std::isnan(std::abs(A1D_ELEM(v2,n)))) A1D_ELEM(v2,n)=0; } tempPcaAnalyzer2.addVector(v2); //mI.setXmippOrigin(); //auto_correlation_matrix(mI*ROI,autoCorr); //auto_correlation_matrix(nI,autoCorr); autoCorr.window(smallAutoCorr,-5,-5, 5, 5); smallAutoCorr.copy(temp); svdcmp(temp,U,D,V); for (int n = 0; n < numDescriptors3; ++n) A1D_ELEM(v3,n)=(float)VEC_ELEM(D,n); //A1D_ELEM(v3,n)=(float)VEC_ELEM(D,n)/VEC_ELEM(D,0); tempPcaAnalyzer3.addVector(v3); double minVal=0.; double maxVal=0.; mI.computeDoubleMinMax(minVal,maxVal); compute_hist(mI, hist, minVal, maxVal, 100); for (int n=0 ; n <= numDescriptors4-1 ; n++) { A1D_ELEM(v4,n)= (hist.percentil((n+1)*10)); } tempPcaAnalyzer4.addVector(v4); #ifdef DEBUG if (img.name()==name1) { FileName fpName = "test.txt"; mI.write(fpName); fpName = "test3.txt"; nI.write(fpName); } #endif imgno++; imgnoPCA++; if (imgno % c == 0 && verbose>0) progress_bar(imgno); } tempPcaAnalyzer0.evaluateZScore(2,20,trained); tempPcaAnalyzer1.evaluateZScore(2,20,trained); tempPcaAnalyzer2.evaluateZScore(2,20,trained); tempPcaAnalyzer3.evaluateZScore(2,20,trained); tempPcaAnalyzer4.evaluateZScore(2,20,trained); pcaAnalyzer.push_back(tempPcaAnalyzer0); pcaAnalyzer.push_back(tempPcaAnalyzer1); pcaAnalyzer.push_back(tempPcaAnalyzer1); pcaAnalyzer.push_back(tempPcaAnalyzer3); pcaAnalyzer.push_back(tempPcaAnalyzer4); }