Пример #1
0
bool compareImage_v2(MyImage &img_logo, MyImage &img_pic)
{
	int row_n = img_pic.getHeight() / BLOCK_SIZE;
	int col_n = img_pic.getWidth() / BLOCK_SIZE;
	
	int *his_logo = getHistogram(img_logo, 0, 0, img_logo.getHeight(), img_logo.getWidth());
	//int *his_logo = getHistogram_H(img_logo, 0, 0, img_logo.getHeight(), img_logo.getWidth());
	//int *his_pic = getHistogram_H(img_pic, 0, 0, img_pic.getHeight(), img_pic.getWidth());
	
	//print_arr(his_logo, histo_size);
	//print_arr(his_logo, histo_size_h);
	//delete his_pic;
	double *norm_logo = normalize(his_logo, histo_size);
	//double *norm_logo = normalize(his_logo, histo_size_h);
	//print_arr_d(norm_logo, histo_size);
	//print_arr_d(norm_logo, histo_size_h);
	int **block_histos = new int*[row_n * col_n];

	int total_blc = 0;
	for(int i = 0; i < img_pic.getHeight(); i += BLOCK_SIZE) {
		for(int j = 0; j < img_pic.getWidth(); j += BLOCK_SIZE) {
			//TRACE("i: %d, j: %d\n", i, j);
			block_histos[total_blc++] = getHistogram(img_pic, i, j, i + BLOCK_SIZE, j + BLOCK_SIZE);
		//	print_arr(block_histos[total_blc - 1], H_N);
		}
	}

	int window_size = min(row_n, col_n);
	//double min_diff = 1000.0;
	//int min_x = -1, min_y = -1, min_size = -1;
	std::priority_queue<Box, std::vector<Box>, CompareBox> best_boxes;
	int max_heap_size = 5;
	while(window_size > 0) {
		for(int row = 0; row <= row_n - window_size; row++) {
			for(int col = 0; col <= col_n - window_size; col++) {
				
				int *local_histo = new int[histo_size];
				//int *local_histo = new int[histo_size_h];
				for(int x = 0; x < histo_size; x++) local_histo[x] = 0;
				//for(int x = 0; x < histo_size_h; x++) local_histo[x] = 0;
				for(int x = row; x < row + window_size; x++) {
					for(int y = col; y < col + window_size; y++) {
						int block_index = x * col_n + y;
						for(int z = 0; z < histo_size; z++)
						//for(int z = 0; z < histo_size_h; z++)
							local_histo[z] += block_histos[block_index][z];
					}
				}
				
				double *norm_local = normalize(local_histo, histo_size);
				//double *norm_local = normalize(local_histo, histo_size_h);
				//print_arr_d(norm_local, H_N);
				//print_arr_d(norm_logo, H_N);
				double diff = differ(norm_local, norm_logo, histo_size);
				//double diff = differ(norm_local, norm_logo, histo_size_h);
				//TRACE("row: %d, col: %d, size: %d, diff: %lf\n", row, col, window_size, diff);
				/*
				if(row == 3 && col == 6 && window_size == 2) {
					print_arr_d(norm_local, histo_size);
					TRACE("diff: %lf\n", diff);
				}
				*/
				if(best_boxes.size() == max_heap_size && best_boxes.top().diff > diff) {
					delete best_boxes.top().histogram;
					best_boxes.pop();
				}
				if(best_boxes.size() < max_heap_size) {
					Box new_box = {row, col, window_size, diff, local_histo};
					//TRACE("r: %d, c: %d, size: %d, diff: %lf\n", new_box.row, new_box.col, new_box.len, new_box.diff);
					best_boxes.push(new_box);
				}
				else
					delete local_histo;
				delete norm_local;
			}
		}
		window_size--;
	}
	//TRACE("row: %d, col: %d, size: %d, diff: %lf\n", min_y, min_x, min_size, min_diff);
	//int length = min_size * BLOCK_SIZE;
	img_pic.RGBtoGray();
	img_logo.RGBtoGray();
	unsigned char **pyramid = create_img_pyr(img_logo, 0);
	

	int min_err = (1 << 31) - 1;
	double min_diff = 10.0;
	//printf("here\n");
	while(!best_boxes.empty()) {
		Box best_box = best_boxes.top();
		TRACE("row: %d, col: %d, size: %d, diff: %lf\n", best_box.row, best_box.col, best_box.len, best_box.diff);
		//printf("row: %d, col: %d, size: %d, diff: %lf\n", best_box.row, best_box.col, best_box.len, best_box.diff);
		//print_arr(best_box.histogram, histo_size);
		//print_arr(best_box.histogram, histo_size_h);
		img_pic.DrawBox(best_box.row * BLOCK_SIZE, best_box.col * BLOCK_SIZE, (best_box.row  + best_box.len)* BLOCK_SIZE, (best_box.col + best_box.len) * BLOCK_SIZE);
		best_boxes.pop();
		if(best_boxes.empty())
		    min_err = diff_pic(pyramid[best_box.len - 1], best_box.len, img_pic, best_box.row * BLOCK_SIZE, best_box.col * BLOCK_SIZE, (best_box.row  + best_box.len)* BLOCK_SIZE, (best_box.col + best_box.len) * BLOCK_SIZE);
		//TRACE("cur_err: %d\n", cur_err);
		//printf("cur_err: %d\n", cur_err);
		//if(cur_err < min_err) min_err = cur_err;
		if(best_box.diff < min_diff) min_diff = best_box.diff;
		delete best_box.histogram;
	}
	TRACE("min_square_error: %d\n", min_err);
	TRACE("min_diff: %f\n", min_diff);
	delete his_logo;
	delete norm_logo;
	
	//delete [] block_histos;
	for(int i = 0; i < total_blc; i++) {
		delete block_histos[i];
	}
	for(int i = 0; i < 9; i++) {
		delete pyramid[i];
	}
	delete pyramid;
	delete block_histos;
	if(min_diff <= 0.02) return true;
	if(min_diff >= 0.33) return false;
	return min_err < 400000;
}