void Saliency::Evaluate(const string& resultW, const string &gtImgW, vecD &precision, vecD &recall)
{
	vecS names;
	string inDir;
	int imgNum = CmFile::GetNames(resultW, names, inDir);
	int COLOR_NUM = 256;
	precision.resize(COLOR_NUM, 0);
	recall.resize(COLOR_NUM, 0);

	string truthDir = CmFile::GetFolder(gtImgW);
	size_t pathSize = gtImgW.size(), nPos = gtImgW.find_last_of('.');
	string ext = gtImgW.substr(nPos, pathSize - nPos);

	for (int i = 0; i < imgNum; i++)
	{
		CmLog::LogProgress("Processing %-40s\r", names[i].c_str());
		Mat resS = imread(inDir + names[i], CV_LOAD_IMAGE_GRAYSCALE);
		CV_Assert_(resS.data != NULL, ("Can't load saliency map: %s\n", names[i].c_str()));
		names[i].resize(names[i].find_last_of("_"));
		Mat truM = imread(truthDir + CmFile::GetNameNE(names[i]) + ext, CV_LOAD_IMAGE_GRAYSCALE);
		compare(truM, 128, truM, CMP_GE);
		if (truM.data == NULL)
		{
			CmLog::LogLine("Evaluation stopped due to missing ground truth results\n");
			exit(1);
		}
		CV_Assert_(resS.size() == truM.size(), ("Saliency map and ground truth image size mismatch\n"));

		double groundTruth = sum(truM).val[0];
#pragma omp parallel for
		for (int thr = 0; thr < COLOR_NUM; thr++)
		{
			Mat resM;
			compare(resS, thr, resM, CMP_GE);
			double res = sum(resM).val[0];
			bitwise_and(resM, truM, resM);
			double common = sum(resM).val[0];

			precision[thr] += common/(res + 1e-8);
			recall[thr] += common/(groundTruth + 1e-8);
		}
	}

	for (int thr = 0; thr < COLOR_NUM; thr++)
	{
		precision[thr] /= imgNum;
		recall[thr] /= imgNum;
	}
}
示例#2
0
// Load mask image and threshold thus noisy by compression can be removed
Mat CmFile::LoadMask(CStr& fileName)
{
	Mat mask = imread(fileName, CV_LOAD_IMAGE_GRAYSCALE);
	CV_Assert_(mask.data != NULL, ("Can't find mask image: %s", _S(fileName)));
	compare(mask, 128, mask, CV_CMP_GT);
	return mask;
}
示例#3
0
// Get potential bounding boxes, each of which is represented by a Vec4i for (minX, minY, maxX, maxY).
// The trained model should be prepared before calling this function: loadTrainedModel() or trainStageI() + trainStageII().
// Use numDet to control the final number of proposed bounding boxes, and number of per size (scale and aspect ratio)
void Objectness::getObjBndBoxes(CMat &img3u, ValStructVec<float, Vec4i> &valBoxes, int numDetPerSize)
{
    CV_Assert_(filtersLoaded() , ("SVM filters should be initialized before getting object proposals\n"));
    vecI sz;
    predictBBoxSI(img3u, valBoxes, sz, numDetPerSize, false);
    predictBBoxSII(valBoxes, sz);
    return;
}
示例#4
0
void DataSetVOC::loadBox(const FileNode &fn, vector<Vec4i> &boxes, vecI &clsIdx){
	string isDifficult;
	fn["difficult"]>>isDifficult;
	if (isDifficult == "1")
		return; 

	string strXmin, strYmin, strXmax, strYmax;
	fn["bndbox"]["xmin"] >> strXmin;
	fn["bndbox"]["ymin"] >> strYmin;
	fn["bndbox"]["xmax"] >> strXmax;
	fn["bndbox"]["ymax"] >> strYmax;
	boxes.push_back(Vec4i(atoi(_S(strXmin)), atoi(_S(strYmin)), atoi(_S(strXmax)), atoi(_S(strYmax))));

	string clsName;
	fn["name"]>>clsName;
	clsIdx.push_back(findFromList(clsName, classNames));	
	CV_Assert_(clsIdx[clsIdx.size() - 1] >= 0, ("Invalidate class name\n"));
}
示例#5
0
vecD BenchMarkLatex::readVectorFromMatlabeFile(CStr &fileName, CStr &vecName)
{
	ifstream fin(fileName);
	CV_Assert(fin.is_open());
	string lineStr, token = vecName + " = [";
	while (getline(fin, lineStr))
		if (strncmp(_S(lineStr), _S(token), token.size() - 1) == 0)
			break;

	CV_Assert_(lineStr.size(), ("Can't load vector '%s' from: %s\n", _S(vecName), _S(fileName)));
	lineStr = lineStr.substr(token.size());
	istringstream sIn(lineStr);
	vecD scores;
	double s;
	while (sIn>>s)
		scores.push_back(s);
	return scores;
}
示例#6
0
void CmEvaluation::MeanAbsoluteError(CStr inDir, CStr salDir, vecS des, bool zeroMapIfMissing)
{
	vecS namesNE;
	int imgNum = CmFile::GetNamesNE(inDir + "*.jpg", namesNE), count = 0, methodNum = des.size();
	vecD costs(des.size());
	for (int i = 0; i < imgNum; i++){
		Mat gt = imread(inDir + namesNE[i] + ".png", CV_LOAD_IMAGE_GRAYSCALE);
		if (gt.empty())	{
			if (zeroMapIfMissing){
				Mat img = imread(inDir + namesNE[i] + ".jpg");
				gt = Mat::zeros(img.size(), CV_8U);
			}
			else 
				continue; 
		}		

		//printf("%s.jpg ", _S(namesNE[i]));
		gt.convertTo(gt, CV_32F, 1.0/255);
#pragma omp parallel for
		for (int j = 0; j < methodNum; j++){
			Mat res = imread(salDir + namesNE[i] + "_" + des[j] + ".png", CV_LOAD_IMAGE_GRAYSCALE);
			CV_Assert_(res.data != NULL, ("Can't load file %s\n", _S(namesNE[i] + "_" + des[j] + ".png")));
			if (res.size != gt.size){
				printf("size don't match %s\n", _S(namesNE[i] + "_" + des[j] + ".png"));
				resize(res, res, gt.size());
				CmFile::MkDir(salDir + "Out/");
				imwrite(salDir + "Out/" + namesNE[i] + "_" + des[j] + ".png", res);
			}
			res.convertTo(res, CV_32F, 1.0/255);
			cv::absdiff(gt, res, res);
			costs[j] += sum(res).val[0] / (gt.rows * gt.cols);
		}
		count++;
	}

	for (size_t j = 0; j < des.size(); j++)
		printf("%4s:%5.3f ", _S(des[j]), costs[j]/count);
	printf("\n");
}
示例#7
0
// Return mean absolute error (MAE)
double CmEvaluation::Evaluate_(CStr &gtImgW, CStr &inDir, CStr& resExt, vecD &precision, vecD &recall, vecD &tpr, vecD &fpr)
{
	vecS names;
	string truthDir, gtExt;
	int imgNum = CmFile::GetNamesNE(gtImgW, names, truthDir, gtExt); 
	precision.resize(NUM_THRESHOLD, 0);
	recall.resize(NUM_THRESHOLD, 0);
	tpr.resize(NUM_THRESHOLD, 0);
	fpr.resize(NUM_THRESHOLD, 0);
	if (imgNum == 0){
		printf("Can't load ground truth images %s\n", _S(gtImgW));
		return 10^20;
	}
	else
		printf("Evaluating %d saliency maps ... \r", imgNum);

	double mea = 0;
	for (int i = 0; i < imgNum; i++){
		if(i % 100 == 0)
			printf("Evaluating %03d/%d %-40s\r", i, imgNum, _S(names[i] + resExt));
		Mat resS = imread(inDir + names[i] + resExt, CV_LOAD_IMAGE_GRAYSCALE);
		CV_Assert_(resS.data != NULL, ("Can't load saliency map: %s\n", _S(names[i] + resExt)));
		normalize(resS, resS, 0, 255, NORM_MINMAX);
		Mat gtFM = imread(truthDir + names[i] + gtExt, CV_LOAD_IMAGE_GRAYSCALE), gtBM;
		if (gtFM.data == NULL) 
			continue;
		CV_Assert_(resS.size() == gtFM.size(), ("Saliency map and ground truth image size mismatch: %s\n", _S(names[i])));
		compare(gtFM, 128, gtFM, CMP_GT);
		bitwise_not(gtFM, gtBM);
		double gtF = sum(gtFM).val[0];
		double gtB = resS.cols * resS.rows * 255 - gtF;


#pragma omp parallel for
		for (int thr = 0; thr < NUM_THRESHOLD; thr++){
			Mat resM, tpM, fpM;
			compare(resS, thr * STEP, resM, CMP_GE);
			bitwise_and(resM, gtFM, tpM);
			bitwise_and(resM, gtBM, fpM);
			double tp = sum(tpM).val[0]; 
			double fp = sum(fpM).val[0];
			//double fn = gtF - tp;
			//double tn = gtB - fp;

			recall[thr] += tp/(gtF+EPS);
			double total = EPS + tp + fp;
			precision[thr] += (tp+EPS)/total;

			tpr[thr] += (tp + EPS) / (gtF + EPS);
			fpr[thr] += (fp + EPS) / (gtB + EPS);
		}

		gtFM.convertTo(gtFM, CV_32F, 1.0/255);
		resS.convertTo(resS, CV_32F, 1.0/255);
		cv::absdiff(gtFM, resS, resS);
		mea += sum(resS).val[0] / (gtFM.rows * gtFM.cols);
	}

	int thrS = 0, thrE = NUM_THRESHOLD, thrD = 1;
	for (int thr = thrS; thr != thrE; thr += thrD){
		precision[thr] /= imgNum;
		recall[thr] /= imgNum;
		tpr[thr] /= imgNum;
		fpr[thr] /= imgNum;
	}
	return mea/imgNum;
}