C++ MyImage::getWidth方法代码示例

int main(int argc, char** argv){
	if(argc < 3){
		std::cout << "usage:"<<std::endl;
		std::cout << "composite [foregroundImagename] [backgroundImagename]" << std::endl;
		std::cout << "or" <<std::endl;
		std::cout << "composite [foregroundImagename] [backgroundImagename] [outputIMagename]" << std::endl;
		exit(-1);
	}

	FileIO::getInstance().readFromFileToImage(foreImage, argv[1]);
	FileIO::getInstance().readFromFileToImage(backImage, argv[2]);
	imageToBeOutput = foreImage.over(backImage,0,0);
	display_data = new GLubyte[imageToBeOutput.getWidth()*imageToBeOutput.getHeight()*4];
	imageToBeOutput.displayOutput(display_data);

	if(argc>3){
		FileIO::getInstance().writeImageToFile(imageToBeOutput,argv[3]);
	}

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA);
	glutInitWindowSize(imageToBeOutput.getWidth(), imageToBeOutput.getHeight());
	glutInitWindowPosition(0, 0);
	glutCreateWindow(argv[0]);
	init();
	glutDisplayFunc(display);
	glutMainLoop();
	return 0;
}

//callback in glut loop
void display(void)
{
	std::cout << imageToBeOutput.getWidth() << " " << imageToBeOutput.getHeight() << " " << imageToBeOutput.getChannels()<<std::endl;

	glClear(GL_COLOR_BUFFER_BIT);
	glDrawPixels(imageToBeOutput.getWidth(), imageToBeOutput.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, display_data);
	glFlush();
}

bool compareImage_basic(const MyImage &img_logo, const MyImage &img_pic)
{
	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, H_N);
    print_arr(his_pic, H_N);
    int total_pixel = img_logo.getWidth() * img_logo.getHeight();
	retainMajority(his_logo, 0.9, H_N);
	TRACE("After retaining majority\n");
	print_arr(his_logo, H_N);
	filter(his_logo, his_pic, H_N);
	TRACE("After filtering\n");
	print_arr(his_pic, H_N);
	double *norm_his_logo = normalize(his_logo, H_N);
	double *norm_his_pic = normalize(his_pic, H_N);
	double diff = differ(norm_his_logo, norm_his_pic, H_N);
    TRACE("ecu diff: %lf\n", diff);
    delete his_logo;
    delete his_pic;
    delete norm_his_logo;
    delete norm_his_pic;

	return diff <= THRESHOLD;
}

void sendDecodeSequentialMode(void* storage){
	TwoByte* st = (TwoByte*) storage;

	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
										
	Byte* imgd = workingImage.getImageData();
	
	unsigned int q = 1<<quantizationLevel;

	TwoByte* tblock = new TwoByte[192];
	Byte* idctblock = new Byte[192];

	for(int y = 0; y < h; y+=8){
		for(int x = 0; x < w; x+=8){
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int src = ((y + yy)*w + (x + xx))*3;
					int dest = (yy*8 + xx)*3;
					tblock[dest] = st[src]*q;
					tblock[dest + 1] = st[src + 1]*q;  
					tblock[dest + 2] = st[src + 2]*q;  
				}
			}

			doIDCT(tblock, idctblock);
			
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int dest = ((y + yy)*w + (x + xx))*3;
					int src = (yy*8 + xx)*3;
					imgd[dest]  = idctblock[src];					
					imgd[dest + 1] = idctblock[src + 1];					
					imgd[dest + 2] = idctblock[src + 2];  					
				}
			}
			drawImage(&workingImage, nextStart);
			Sleep(latency);
		}
	}
		
	delete[] tblock;
	delete[] idctblock;
	MessageBox(NULL, "DECODING DONE", "Status", NULL);
}

void decodeProgressiveModeSpectralSelection(TwoByte* st){
	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
										
	Byte* imgd = workingImage.getImageData();
	
	unsigned int q = 1<<quantizationLevel;

	TwoByte* tblock = new TwoByte[192];
	Byte* idctblock = new Byte[192];

	memset(tblock, 0x00, sizeof(TwoByte)*192);
	memset(idctblock, 0x00, sizeof(Byte)*192);

	for(int y = 0; y < h; y+=8){
		for(int x = 0; x < w; x+=8){
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int src = ((y + yy)*w + (x + xx))*3;
					int dest = (yy*8 + xx)*3;
					tblock[dest] = st[src]*q;
					tblock[dest + 1] = st[src + 1]*q;  
					tblock[dest + 2] = st[src + 2]*q;  
				}
			}

			doIDCT(tblock, idctblock);
			
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int dest = ((y + yy)*w + (x + xx))*3;
					int src = (yy*8 + xx)*3;
					imgd[dest]  = idctblock[src];					
					imgd[dest + 1] = idctblock[src + 1];					
					imgd[dest + 2] = idctblock[src + 2];  					
				}
			}
		}
	}
		
	delete[] tblock;
	delete[] idctblock;
	drawImage(&workingImage, nextStart);		
}

void encode(TwoByte *store){
	int h = originalImage.getHeight();
	int w = originalImage.getWidth();										
	Byte* imgd = originalImage.getImageData();	

	Byte* tblock = new Byte[192];
	double* dctblock = new double[192];
	
	memset(tblock, 0x00, sizeof(Byte)*192);
	memset(dctblock, 0x00, sizeof(double)*192);
	
	unsigned int  q = 1<<quantizationLevel;

	for(int y = 0; y < h; y+=8){
		for(int x = 0; x < w; x+=8){
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int src = ((y+yy)*w + (x + xx))*3;
					int dest = (yy*8 + xx)*3;
					tblock[dest] = imgd[src];
					tblock[dest + 1] = imgd[src + 1];  
					tblock[dest + 2] = imgd[src + 2];  
				}
			}

			doDCT(tblock, dctblock);			

			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int dest = ((y+yy)*w + (x + xx))*3;
					int src = (yy*8 + xx)*3;

					store[dest]  = (TwoByte)(dctblock[src]/q); 
					store[dest + 1] = (TwoByte)(dctblock[src + 1]/q);
					store[dest + 2] = (TwoByte)(dctblock[src + 2]/q);   
				}
			}
		}
	}
	delete[] tblock;
	delete[] dctblock;
}

void sendSuccessiveBits(void* storage){
	TwoByte* st = (TwoByte*) storage;
	
	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
	int len = h*w*3;
	
	TwoByte *newst = new TwoByte[len];
	memset(newst, 0x00, sizeof(TwoByte)*len);
	TwoByte offset = 1<<12;
	for(int k = 12; k >= 0; --k){
		for(int i = 0; i < len; ++i){
			TwoByte temp = st[i] + offset;						
			temp &= (1<<k);				
			newst[i] |= temp;			
		}
		decodeProgressiveModeBitApproximation(newst, offset);	
		Sleep(latency);
	}
	delete[] newst;
	MessageBox(NULL, "DECODING DONE", "Status", NULL);
}

//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;
	TCHAR szHello[MAX_LOADSTRING];
	LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
	
	switch (message)
	{
		case WM_COMMAND:
			wmId    = LOWORD(wParam); 
			wmEvent = HIWORD(wParam); 
			// Parse the menu selections:
			switch (wmId)
			{
				case IDM_ABOUT:
				   DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
				   break;
				case IDM_EXIT:
				   DestroyWindow(hWnd);
				   break;
				default:
				   return DefWindowProc(hWnd, message, wParam, lParam);
			}
			break;
		case WM_PAINT:
			{
				hdc = BeginPaint(hWnd, &ps);
				// TODO: Add any drawing code here...
				RECT rt;
				GetClientRect(hWnd, &rt);

				// Top Text
				char text[1000];
				
				// Image Header setup
				BITMAPINFO bmi;
				CBitmap bitmap;
				memset(&bmi,0,sizeof(bmi));
				bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
				bmi.bmiHeader.biWidth = myImage.getWidth();
				bmi.bmiHeader.biHeight = -myImage.getHeight();  // Use negative height.  DIB is top-down.
				bmi.bmiHeader.biPlanes = 1;
				bmi.bmiHeader.biBitCount = 24;
				bmi.bmiHeader.biCompression = BI_RGB;
				bmi.bmiHeader.biSizeImage = myImage.getWidth()*myImage.getHeight();

				// Draw Processed image
				sprintf(text, "\n       %s -> display", myImage.getImagePath());
				DrawText(hdc, text, strlen(text), &rt, DT_LEFT);
				sprintf(text, "\n %s -> Gray Scaled -> YUV -> DCT -> Quant [ %d ] -> Dequant [ %d ] -> IDCT [ %d Co-Efficient(s) ]       ", myImage.getImagePath(), myImage.getQuant(), myImage.getQuant(), myImage.getCoEff());
				DrawText(hdc, text, strlen(text), &rt, DT_RIGHT);

				// Draw image 
				SetDIBitsToDevice(hdc,
								  100,100,myImage.getWidth(),myImage.getHeight(),
								  0,0,0,myImage.getHeight(),
								  myImage.getBytesRGBSTART(),&bmi,DIB_RGB_COLORS);

				SetDIBitsToDevice(hdc,
								  300+myImage.getWidth()+50,100,myImage.getWidth(),myImage.getHeight(),
								  0,0,0,myImage.getHeight(),
								  myImage.getBytesRGBEND(),&bmi,DIB_RGB_COLORS);
				
				EndPaint(hWnd, &ps);
			}
			break;
		case WM_DESTROY:
			PostQuitMessage(0);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return 0;
}

//.........这里部分代码省略.........
        
        if (good_matches.size() >= 4)
        {
            
            Point2f averagePoint;
            for( int i = 0; i < good_matches.size(); i++ )
            {
                obj.push_back( kp_object[ good_matches[i].queryIdx ].pt );
                scene.push_back( kp_image[ good_matches[i].trainIdx ].pt );
                averagePoint.x += kp_image[ good_matches[i].trainIdx ].pt.x;
                averagePoint.y += kp_image[ good_matches[i].trainIdx ].pt.y;
            }
            
            averagePoint.x /= good_matches.size();
            averagePoint.y /= good_matches.size();
            int inRange = 0;
            int delta = 60;
            for( int i = 0; i < good_matches.size(); i++ ){
                int x =kp_image[ good_matches[i].trainIdx ].pt.x;
                int y =kp_image[ good_matches[i].trainIdx ].pt.y;

                if ((x > (averagePoint.x - delta) && x < (averagePoint.x + delta)) && (y > (averagePoint.y - delta) && (y < (averagePoint.y + delta)))) {
                    inRange++;
                }
                
            } 

            if (probability + (double)inRange / good_matches.size() > 0.8) {
                printf("found\n");
            }else{
                MyImage *objectPic = new MyImage();
                objectPic->setWidth(352);
                objectPic->setHeight(288);
                objectPic->setImagePath(argv[1]);
                objectPic->ReadImage();
                
                cv::Mat objectImage(Size(352, 288), CV_8UC3, objectPic->getImageData());
                cv::Mat smallerQueryImage;
                resize(objectImage, smallerQueryImage, Size(16, 16), 0,0, INTER_CUBIC);

                cvtColor(objectImage, objectImage, COLOR_RGB2HSV);

                for (int x = 0; x < 352; x += 16) {
                    for (int y = 0; y < 288; y += 16) {
                        Rect region(Point(x, y), Size(16, 16));
                        
                        cv::Mat subSampleOfScene = image(region);

                        cvtColor(subSampleOfScene, subSampleOfScene, COLOR_RGB2HSV);
                        int h_bins = 50; int s_bins = 60;
                        int histSize[] = { h_bins, s_bins };

                        float h_ranges[] = { 0, 180 };
                        float s_ranges[] = { 0, 256 };
                        
                        const float* ranges[] = { h_ranges, s_ranges };
                        
                        int channels[] = { 0, 1 };
                        MatND hist_base;
                        MatND hist_test;
                        calcHist( &smallerQueryImage, 1, channels, Mat(), hist_base, 2, histSize, ranges, true, false );
                        normalize( hist_base, hist_base, 0, 1, NORM_MINMAX, -1, Mat() );

                        calcHist( &subSampleOfScene, 1, channels, Mat(), hist_test, 2, histSize, ranges, true, false );
                        normalize( hist_test, hist_test, 0, 1, NORM_MINMAX, -1, Mat() );
                        double base_test1 = compareHist(hist_base, hist_test, CV_COMP_CORREL);
                        if (base_test1 > 0.1) {
                            probability += base_test1;
                        }

                    }
                }
                
                if (probability > 0.8) { 
                    
                    printf("found with confidence: %f\n", probability);
                }
                else{
                    printf("not found\n");
                }
               
            }
            
            

            
            line(img_matches,  cv::Point2f(averagePoint.x - 40 + sceneMyPic->getWidth(), averagePoint.y - 40), cv::Point2f(averagePoint.x + 40 + sceneMyPic->getWidth(), averagePoint.y - 40), cv::Scalar(0, 255, 0), 4);
            line(img_matches, cv::Point2f(averagePoint.x + 40 + sceneMyPic->getWidth(), averagePoint.y - 40), cv::Point2f(averagePoint.x + 40 + sceneMyPic->getWidth(), averagePoint.y + 40), cv::Scalar(0, 255, 0), 4);
            line(img_matches, cv::Point2f(averagePoint.x + 40 + sceneMyPic->getWidth(), averagePoint.y + 40), cv::Point2f(averagePoint.x - 40 + sceneMyPic->getWidth(), averagePoint.y + 40), cv::Scalar(0, 255, 0), 4);
            line(img_matches, cv::Point2f(averagePoint.x - 40 + sceneMyPic->getWidth(), averagePoint.y + 40), cv::Point2f(averagePoint.x - 40 + sceneMyPic->getWidth(), averagePoint.y - 40), cv::Scalar(0, 255, 0), 4);

            
        }
        imshow("Good matches", img_matches);
        
        key = cv::waitKey(0);
    }
    return 0;

}

void sendSpectralSelection(void* storage){
	TwoByte* st = (TwoByte*) storage;
	
	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
	int len = h*w*3;

	TwoByte *newst = new TwoByte[len];
	memset(newst, 0x00, sizeof(TwoByte)*len);

	int xx, yy;
	int t = 0;
	for(int k= 0; k <= 14; ++k){		
		if((k%7)%2 == 0){
			if(k == 7 || k==14){
				xx = 7;
				yy = k-7;
			}
			else{
				yy = k%7;
				xx = k-yy;
			}
		}
		else{
			xx = k%7;
			yy = k-xx;
		}
		if(yy > xx){
			t = yy - xx;
			for(int i = 0; i <= t; ++i){
				for(int y = 0; y < h; y+=8){
					for(int x = 0; x < w; x+=8){
						int index = ((y + yy)*w + (x + xx))*3;
						newst[index] = st[index];
						newst[index + 1] = st[index + 1];  
						newst[index + 2] = st[index + 2];  				
					}
				}
				decodeProgressiveModeSpectralSelection(newst);
				Sleep(latency);
				yy--;xx++;				
			}			
		}
		else{
			t = xx - yy;
			for(int i = 0; i <= t; ++i){
				for(int y = 0; y < h; y+=8){
					for(int x = 0; x < w; x+=8){
						int index = ((y + yy)*w + (x + xx))*3;
						newst[index] = st[index];
						newst[index + 1] = st[index + 1];  
						newst[index + 2] = st[index + 2];  				
					}
				}
				decodeProgressiveModeSpectralSelection(newst);
				Sleep(latency);
				yy++;xx--;
			}
		}		
	}	
	delete[] newst;
	MessageBox(NULL, "DECODING DONE", "Status", NULL);
}

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);
//.........这里部分代码省略.........

int diff_pic(unsigned char *logo_img_sample, int pyr_i, const MyImage &img_pic, int start_r, int start_c, int end_r, int end_c)
{
	unsigned char *Ybuf_pic = img_pic.getYbuf();
	int block_unit = 8;
	int block_len = pyr_i * BLOCK_SIZE;

	int error = 0;
	for(int i = start_r; i < end_r; i += block_unit) {
		for(int j = start_c; j < end_c; j += block_unit) {
	
			int min_mse = (1 << 31) - 1;
			for(int row = 0; row < block_len; row += block_unit) {
				for(int col = 0; col < block_len; col += block_unit) {

					int block_err = 0;
					for(int blc_i = 0; blc_i < block_unit; blc_i++) {
						for(int blc_j = 0; blc_j < block_unit; blc_j++) {
							int diff = logo_img_sample[(row + blc_i) * block_len + col + blc_j] - Ybuf_pic[(i + blc_i) * img_pic.getWidth() + j + blc_j];
							block_err += diff * diff;
						}
					}
					if(block_err < min_mse) min_mse = block_err;
				}
			}
			error += min_mse;
		}
	}
	return error / (block_len / 8) / (block_len / 8);
}