コード例 #1
0
void ExtractFeaturesFromEachFrame(const std::string & video_source,
                                  std::vector<Features> features_collection,
                                  const cv::Size & window_size,
                                  bool scale) {
  std::srand(std::time(0));

  cv::VideoCapture video(video_source);
  if(!video.isOpened()) return;

  cv::HOGDescriptor hog;
  hog.winSize=window_size;

  cv::Mat frame;
  cv::Mat extracted_frame;
  Features features;
  while(video.read(frame)) {
    if(scale) cv::resize(frame, extracted_frame, window_size);
    else {
      // Extract frame
      cv::Rect patch;
      patch.width=window_size.width;
      patch.height=window_size.height;
      patch.x=std::rand()%(frame.cols-window_size.width);
      patch.y=std::rand()%(frame.rows-window_size.height);
      extracted_frame=((frame)(patch)).clone();

      features_collection.push_back(Features((features_collection.size()==0?0:features_collection.front().size())));
      ComputeFeatures(extracted_frame, features_collection.back(), window_size);
    }
    features.clear();
  }
}
コード例 #2
0
ファイル: tree.cpp プロジェクト: kevin1kevin1k/dsa2015
	Example(int a = 0) : ans(a) { 
		feat.clear();
		feat.resize(MAX, 0);
	}
コード例 #3
0
/**
 * Extracts the features from the buffers for the given sensor code. 
 * If useSpecSize is set to true only the last specSize frames in the buffer will be taken into account. 
 */
Features GestureManagement::extractFeatures(int sensor, int specSize, bool useSpecSize) {
	if (config->getInt("verbosity") > 2) {
		cout << "* FEATURE EXTRACTION *************" << endl;
		cout << "Sensor: " << sensor << endl;
	}
	Features f;
	f.clear();
	// for every measurement (accX, accY, ...)
	vector<int> indices = config->getInts("sensor data indices");
	
	int fullsize = buffers.at(sensor)->size();
	int size = fullsize;
	if (useSpecSize && fullsize > specSize) {
		size = specSize;
	}
	int offset = 0;
	if (useSpecSize) {
		offset = fullsize - size;
	}

	vector<int> meanPositions;
	meanPositions.clear();
	if (config->getInt("use mean") == 1) {
		int chunks = config->getInt("number of mean window chunks");
		for (int i=0; i<chunks; ++i) {
			meanPositions.push_back(offset+i*size/chunks);
		}
		meanPositions.push_back(fullsize-1);
	}

	vector<int> sdPositions;
	sdPositions.clear();
	if (config->getInt("use standard deviation") == 1) {
		int chunks = config->getInt("number of sd window chunks");
		for (int i=0; i<chunks; ++i) {
			sdPositions.push_back(offset+i*size/chunks);
		}
		sdPositions.push_back(fullsize-1);
	}

	vector<int> mcrPositions;
	mcrPositions.clear();
	if (config->getInt("use mean crossing rate") == 1) {
		int chunks = config->getInt("number of mcr window chunks");
		for (int i=0; i<chunks; ++i) {
			mcrPositions.push_back(offset+i*size/chunks);
		}
		mcrPositions.push_back(fullsize-1);
	}

	for (vector<int>::iterator it=indices.begin(); it!=indices.end(); ++it) {
		if (config->getInt("verbosity") > 2) {
			cout << "Index:  " << *it << endl;
		}

		if (config->getInt("use mean") == 1) {
			for (int i=1; i<meanPositions.size(); ++i) {
				float mean = extr.at(sensor)->getMean(*it,meanPositions.at(i-1),meanPositions.at(i));
				if (config->getInt("verbosity") > 2) {
					cout << "Mean:   " << mean << endl;
				}
				f.push_back(mean);
			}
		}

		if (config->getInt("use standard deviation") == 1) {
			for (int i=1; i<sdPositions.size(); ++i) {
				float sd = extr.at(sensor)->getStandardDeviation(*it,sdPositions.at(i-1),sdPositions.at(i));
				if (config->getInt("verbosity") > 2) {
					cout << "SD:     " << sd << endl;
				}
				f.push_back(sd);
			}
		}

		if (config->getInt("use mean crossing rate") == 1) {
			for (int i=1; i<mcrPositions.size(); ++i) {
				float mcr = extr.at(sensor)->getMeanCrossingRate(*it,mcrPositions.at(i-1),mcrPositions.at(i));			
				if (config->getInt("verbosity") > 2) {
					cout << "MCR:   " << mcr << endl;
				}
				f.push_back(mcr);
			}
		}
	} // for every measurement index (accX, ...)
	if (config->getInt("verbosity") > 2) {
		cout << "**********************************" << endl;
	}
	return f;
}
コード例 #4
0
ファイル: AlphaProcedure.cpp プロジェクト: cran/ddalpha
int Alpha(TPoint *ray){
	/* 0. Subinitialization - clear auxiliary variables and empty and nonsignificant input axes */
	properties.resize(d); for (unsigned int i = 0; i < d; i++){properties[i] = i;} // initialize properties: all available
	features.clear();

	outMatrix(x);

	/* 1. Null-cycle */
	if (numStartFeatures == 2){ // start with two features?
		Feature optFeatureX;
		Feature optFeatureY;
		for (unsigned int i = 0; i < properties.size() - 1; i++){
			for (unsigned int j = i + 1; j < properties.size(); j++){
				/* Calculating minimal error on the plane of the i-th and the j-th properties */
				Feature tmpFeature;
				curFeature = x[properties[i]];
				unsigned int error = DGetMinError(properties[j], &tmpFeature);
#ifdef DEF_OUT_ALPHA
				if (OUT_ALPHA){
					Rcout << properties[i] << ", " << properties[j] << ", " << tmpFeature.angle << ", " << error << ", " << endl;
				}
#endif
				if (error < optFeatureY.error){optFeatureX.number = properties[i]; optFeatureY = tmpFeature;}
			}
		}
		features.push_back(optFeatureX);
		features.push_back(optFeatureY);
		for (unsigned int i = 0; i < properties.size(); i++){ // delete recently found X and Y properties
			if (properties[i] == optFeatureX.number){properties.erase(properties.begin() + i);}
			if (properties[i] == optFeatureY.number){properties.erase(properties.begin() + i);}
		}
		curFeature = x[features[0].number];
		UpdateCurFeature();
		outString("Feature 1:");
		outVector(curFeature);
	}

	/* 2. Main cycle */
	/* Searching an optimal feature space while empirical error rate decreases */	
	while(features[features.size() - 1].error > 0 && properties.size() > 0){
		Feature optFeature;
		for (unsigned int i = 0; i < properties.size(); i++){
			/* Calculating minimal error on the plane of the curFeature and the j-th properties */
			Feature tmpFeature;
			unsigned int error = DGetMinError(properties[i], &tmpFeature);
#ifdef DEF_OUT_ALPHA
			if (OUT_ALPHA){
				Rcout << properties[i] << ", " << tmpFeature.angle << ", " << error << ", " << endl;
			}
#endif
			if (error < optFeature.error){optFeature = tmpFeature;}
		}		
		if (optFeature.error < features[features.size() - 1].error){
			features.push_back(optFeature);
			for (unsigned int i = 0; i < properties.size(); i++){ // delete recently found property
				if (properties[i] == optFeature.number){properties.erase(properties.begin() + i);}
			}
			UpdateCurFeature();
			outString("Feature :");
			outVector(curFeature);
		}else{break;}
	}
	
	outString("Features:");
	outFeatures(features);

	/* Restoring the projection vector */
	GetRay(ray);
	return features[features.size() - 1].error;
}