void TestObjectRecognition::addTrainingSet(cv::Mat &trainingData, cv::Mat &labels, int elemCount, int label, int offset) { for (int i = offset; i < elemCount + offset; i++) { trainingData.push_back(featureDetector->detectImageFeatures(i + 1, label)); labels.push_back(label); } }
//codification of the images with the BOW vocabulary void bow_encode(const fs::path& basepath, cv::Mat& descriptors, cv::Mat& labels) { int no_files = 0; std::string class_name = basepath.string(); class_name.erase(class_name.begin(),class_name.end()-2); for(fs::directory_iterator iter(basepath), end; iter != end; ++iter) { fs::directory_entry entry = *iter; if(fs::is_directory(entry.path())) { std::cout << "Processing directory: " << entry.path().string() << std::endl; bow_encode(entry.path(),descriptors,labels); } else { fs::path entryPath = entry.path(); if(entryPath.extension()==".jpg") { // std::cout << "Processing file: " << entry.path().string() << std::endl; no_files++; cv::Mat img = cv::imread(entryPath.string(),CV_LOAD_IMAGE_COLOR); if(!img.empty()) { std::vector<cv::KeyPoint> feature_keypoints; feature_detector.detect(img,feature_keypoints); if(feature_keypoints.empty()) { std::cerr << "Could not find points in image: " << entryPath.string(); std::cerr << std::endl; } else { cv::Mat bowDescriptor; bowDE.compute(img,feature_keypoints,bowDescriptor); descriptors.push_back(bowDescriptor); //std::cout << class_name.c_str() << std::endl; labels.push_back( float( atoi(class_name.c_str()) ) ); feature_keypoints.clear(); //std::cout << local_descriptors.rows << std::endl; ~bowDescriptor; } } else { std::cerr << "Could not read image: " << entryPath.string() << std::endl; } } } } std::cout << "No files: " << no_files << std::endl; }
// TextureFeature::Classifier virtual int predict(const cv::Mat &testFeature, cv::Mat &results) const { int best = -1; double mind=DBL_MAX; nearest(testFeature, features, best, mind, *this); int found = best>-1 ? labels.at<int>(best) : -1; results.push_back(float(found)); results.push_back(float(mind)); results.push_back(float(best)); return 3; }
void ODFeatureDetector2D::findSiftGPUDescriptors(char const *image_name, cv::Mat &descriptors, vector<cv::KeyPoint> &keypoints) { sift_gpu_->RunSIFT(image_name); int nFeat = sift_gpu_->GetFeatureNum();//get feature count //allocate memory for readback vector<SiftGPU::SiftKeypoint> keys(nFeat); //read back keypoints and normalized descritpros //specify NULL if you don’t need keypoints or descriptors vector<float> imageDescriptors(128 * nFeat); sift_gpu_->GetFeatureVector(&keys[0], &imageDescriptors[0]); sift_gpu_->SaveSIFT("1.sift"); //to opencv format keypoints.clear(); descriptors.create(0, 128, CV_32FC1); for(int i = 0; i < nFeat; ++i) { cv::KeyPoint key(keys[i].x, keys[i].y, keys[i].s, keys[i].o); keypoints.push_back(key); cv::Mat descriptor(1, 128, CV_32FC1); for(int x = 0; x < 128; x++) descriptor.at<float>(x) = floor(0.5 + 512.0f * imageDescriptors[(i << 7) + x]); descriptors.push_back(descriptor); } cv::Mat image = cv::imread(image_name); }
cv::Mat_<int> extractProHOGFeatures( const vector<TrainingSet> &xs, int nbins, const cv::Size &cdims, cv::Mat &trows) { cerr << "Extracting feature vectors from " << xs.size() << " training sets..." << endl; cv::Mat_<int> labels(0,0,CV_32SC1); trows.create(0,0,CV_32FC1); int fvsz = 0; int dataCount = 0; int lab = -1; BOOST_FOREACH( const TrainingSet &ts, xs) { lab++; // New dataset label BOOST_FOREACH( const cv::Mat &x, ts) { RFeatures::ProHOG prohog( x, nbins); const cv::Mat pfvRaw = prohog( cdims); cv::Mat pfv32; pfvRaw.convertTo( pfv32, CV_32F); const cv::Mat pfv = pfv32.reshape(1,1); // Single row CV_32FC1 if ( fvsz == 0) fvsz = pfv.cols; assert( fvsz == pfv.cols); trows.push_back(pfv); labels.push_back(lab); dataCount++; } // end foreach
void Feature::SURFExtractor_GPU(vector<cv::KeyPoint> &feature_pts, vector_eigen_vector3f &feature_pts_3d, cv::Mat &feature_descriptors, const cv::Mat &imgRGB, const cv::Mat &imgDepth) { cv::Mat grey; cv::cvtColor(imgRGB, grey, CV_BGR2GRAY); //cv::gpu::printShortCudaDeviceInfo(cv::gpu::getDevice()); cv::gpu::GpuMat gpuRGB, gpuKeypoints, gpuDescriptors; gpuRGB.upload(grey); cv::gpu::SURF_GPU surf; surf(gpuRGB, cv::gpu::GpuMat(), gpuKeypoints, gpuDescriptors); vector<cv::KeyPoint> fpts; cv::Mat descriptors; surf.downloadKeypoints(gpuKeypoints, fpts); gpuDescriptors.download(descriptors); for (int i = 0; i < fpts.size(); i++) { if (imgDepth.at<ushort>(cvRound(fpts[i].pt.y), cvRound(fpts[i].pt.x)) == 0) continue; feature_pts.push_back(fpts[i]); Eigen::Vector3f pt = ConvertPointTo3D(fpts[i].pt.x, fpts[i].pt.y, imgDepth); feature_pts_3d.push_back(pt); feature_descriptors.push_back(descriptors.row(i)); } }
void Feature::SIFTExtractor(vector<cv::KeyPoint> &feature_pts, vector_eigen_vector3f &feature_pts_3d, cv::Mat &feature_descriptors, const cv::Mat &imgRGB, const cv::Mat &imgDepth) { cv::SIFT sift_detector; cv::Mat mask, descriptors; vector<cv::KeyPoint> fpts; sift_detector(imgRGB, mask, fpts, descriptors); for (int i = 0; i < fpts.size(); i++) { if (imgDepth.at<ushort>(cvRound(fpts[i].pt.y), cvRound(fpts[i].pt.x)) == 0) continue; feature_pts.push_back(fpts[i]); Eigen::Vector3f pt = ConvertPointTo3D(fpts[i].pt.x, fpts[i].pt.y, imgDepth); feature_pts_3d.push_back(pt); double norm = 0.0; for (int j = 0; j < descriptors.cols; j++) { norm += descriptors.at<float>(i, j) * descriptors.at<float>(i, j); } norm = sqrt(norm); for (int j = 0; j < descriptors.cols; j++) { descriptors.at<float>(i, j) /= norm; } feature_descriptors.push_back(descriptors.row(i)); } }
void concatChannels(const cv::Mat& src, cv::Mat& dst) { std::vector<cv::Mat> channels; cv::split(src, channels); dst = cv::Mat(); for (VMit vmit = channels.begin(); vmit != channels.end(); ++vmit) { dst.push_back(*vmit); } }
//analysis operator: action analyse; takes the phase signal and gives the sequence of coefficients (representation realm) //from phase signal space to zernike representation void Zernike::analyse(const cv::Mat& sig, cv::Mat& z_coeffs) { z_coeffs.release(); for(cv::Mat z_j : base_) { double l2 = cv::norm(z_j, cv::NORM_L2); double inner_prod = z_j.dot(sig)/(l2*l2); z_coeffs.push_back( inner_prod ); } }
static void randomFat(const vector<cv::Mat> &input, cv::Mat &fat) { cv::Mat_<int> randIdx(1, input.size()); randomIndex(randIdx); for (size_t i=0; i<input.size(); i++) { int idx = randIdx(i); fat.push_back(input[idx].reshape(1,1)); } }
// // concatVectorToMatVertical // bool concatVectorToMatVertical (const std::vector<float> &vector, cv::Mat &mat) { if (vector.size () != mat.cols) { std::cout << "### Size of vector should be equal to cols of Mat." << std::endl; debug (vector.size ()); debug (mat.cols); return false; } cv::Mat temp (vector); cv::Mat temp_t = temp.t (); mat.push_back (temp_t); return true; }
void histogram_generator_eyes::compute_histogram(cv::Mat& image, cv::Mat& histogram){ //Releasing the memory histogram.release(); //Mat aux individual descriptor cv::Mat aux_descriptors; cv::Mat aux_histogram; cv::Mat aux_histogram2; //Aux info to compute the boxes int aux_cols; int aux_rows; //Boxes std::vector<box> boxes; //Cropped aux image cv::Mat cropped_image; //getting the size of the image aux_cols=image.cols; aux_rows=image.rows; //Getting the boxes std::vector<int> binx; std::vector<int> biny; binx.push_back(1); biny.push_back(1); boxes=generateSpatialBoxes(aux_rows, aux_cols, binx , biny); //Crop the images and extraction features for(unsigned int j=0;j<boxes.size();j++){ cropped_image= image(cv::Range(boxes.at(j).minY, boxes.at(j).maxY), cv::Range(boxes.at(j).minX, boxes.at(j).maxX)); aux_descriptors=feature_extract->extract_dsift(cropped_image,2,4); aux_histogram2=clustering->get_histogram(aux_descriptors); transpose(aux_histogram2, aux_histogram2); aux_histogram.push_back(aux_histogram2); } transpose(aux_histogram, aux_histogram); histogram.push_back(aux_histogram); aux_histogram.release(); }
void shuffleRows(const cv::Mat &matrix, cv::Mat& shuffleMatrix) { shuffleMatrix.release(); std::vector <int> seeds; for (int cont = 0; cont < matrix.rows; cont++) { seeds.push_back(cont); } cv::theRNG() = cv::RNG( cv::getTickCount() ); cv::randShuffle(seeds); for (int cont = 0; cont < matrix.rows; cont++) { shuffleMatrix.push_back(matrix.row(seeds[cont])); } }
void Feature::ORBExtractor(vector<cv::KeyPoint> &feature_pts, vector_eigen_vector3f &feature_pts_3d, cv::Mat &feature_descriptors, const cv::Mat &imgRGB, const cv::Mat &imgDepth) { cv::ORB orb_detector; cv::Mat mask, descriptors; vector<cv::KeyPoint> fpts; orb_detector(imgRGB, mask, fpts, descriptors); for (int i = 0; i < fpts.size(); i++) { if (imgDepth.at<ushort>(cvRound(fpts[i].pt.y), cvRound(fpts[i].pt.x)) == 0) continue; feature_pts.push_back(fpts[i]); Eigen::Vector3f pt = ConvertPointTo3D(fpts[i].pt.x, fpts[i].pt.y, imgDepth); feature_pts_3d.push_back(pt); feature_descriptors.push_back(descriptors.row(i)); } }
void SketchRecognizer::readLabelsMat(const std::string &labels, cv::Mat &labelsMat) { std::ifstream labels_in(labels.c_str()); uint labels_size = 0; labels_in >> labels_size; uint class_num = 0; labels_in >> class_num; _labels.clear(); char line[1024] = {0}; labels_in.getline(line, sizeof(line)); //get '\n' for(uint i = 0; i < labels_size; i++) { labels_in.getline(line, sizeof(line)); _labels.push_back(line); cv::Mat temp = cv::Mat::ones(class_num, 1, CV_32FC1) * i; labelsMat.push_back(temp); } labels_in.close(); }
void SketchRecognizer::readSketchsMat(const std::string &sketchs, cv::Mat &sketchsMat) { std::ifstream sketchs_in(sketchs.c_str()); uint sketchsize = 0; sketchs_in >> sketchsize; uint vocabularySize = 0; sketchs_in >> vocabularySize; Vec_f32_t sketch(vocabularySize); for(uint i = 0; i < sketchsize; i++) { cv::Mat temp = cv::Mat::zeros(1, vocabularySize, CV_32FC1); for(uint j = 0; j < vocabularySize; j++) { sketchs_in >> temp.at<float>(0, j); } sketchsMat.push_back(temp); std::cout << "read sketchs " << i <<"/" << sketchsize << "\r" <<std::flush; } std::cout << "read sketchs " << sketchsize <<"/" << sketchsize << "\n" <<std::flush; sketchs_in.close(); }
void ODFeatureDetector2D::findSiftGPUDescriptors1(cv::Mat const &image, cv::Mat &descriptors, vector<cv::KeyPoint> &keypoints) { unsigned char *data = image.data; cv::Mat greyimage; if(image.type() != CV_8U) { cv::cvtColor(image, greyimage, cv::COLOR_BGR2GRAY); data = greyimage.data; } sift_gpu_->RunSIFT(image.cols, image.rows, data, GL_LUMINANCE, GL_UNSIGNED_BYTE); int nFeat = sift_gpu_->GetFeatureNum();//get feature count //allocate memory for readback vector<SiftGPU::SiftKeypoint> keys(nFeat); //read back keypoints and normalized descritpros //specify NULL if you don’t need keypoints or descriptors vector<float> imageDescriptors(128 * nFeat); sift_gpu_->GetFeatureVector(&keys[0], &imageDescriptors[0]); sift_gpu_->SaveSIFT("2.sift"); //to opencv format keypoints.clear(); descriptors.create(0, 128, CV_32FC1); for(int i = 0; i < nFeat; ++i) { cv::KeyPoint key(keys[i].x, keys[i].y, keys[i].s, keys[i].o); keypoints.push_back(key); cv::Mat descriptor(1, 128, CV_32FC1); for(int x = 0; x < 128; x++) descriptor.at<float>(x) = floor(0.5 + (512.0f * imageDescriptors[(i * 128) + x])); descriptors.push_back(descriptor); } //viewImage(image, keypoints); }