Пример #1
0
/** @function main */
int main( int argc, char** argv )
{
    //300 350
    
    double probability = 0.6;

    std::vector<string> sourceVector = saveFileName(argv[1]);
    std::vector<string> searchVector = saveFileName(argv[2]);

    
    double matched = 0;
    
    for(std::vector<string>::iterator sourceIterator = sourceVector.begin(); sourceIterator != sourceVector.end(); sourceIterator++ ){
        for(std::vector<string>::iterator searchIterator = searchVector.begin(); searchIterator != searchVector.end(); searchIterator++ ){
            if (*sourceIterator == *searchIterator) {
                matched++;
                break;
            }
            
            
        }
    }

    probability *= (matched / sourceVector.size());
    
    
    
    MyImage *image = new MyImage();
    image->setWidth(352);
    image->setHeight(288);
    image->setImagePath(argv[1]);

    if(!image->ReadImage()){
        std::cout << "Error reading MyImage" << std::endl;
    }

    printf("%s", argv[1]);
    
    
   FILE *f = fopen(argv[1], "rb");
    if (!f) {
        printf("error\n");
        exit(1);
    }
    unsigned char pixels[352 * 288 * 3];
    fread(pixels, sizeof(unsigned char), 352*288 * 3, f);
    fclose(f);
    cv::Mat object(Size(352, 288), CV_8UC3, pixels);
    
    namedWindow("image", CV_WINDOW_AUTOSIZE);
    imshow("image", object);
    
    if( !object.data )
    {
        std::cout<< "Error reading object " << std::endl;
        return -1;
    }
    
    cv::Mat tmp, alpha;
    threshold(object, object, 255, 0, THRESH_TOZERO_INV);

    cv::Rect myROI(100, 100, 150, 150);
    
    
    int minHessian = 1000;
    
    cv::SurfFeatureDetector detector( minHessian );
    std::vector<cv::KeyPoint> kp_object;
    detector.upright = false;
    detector.detect( object, kp_object );
    
    cv::SurfDescriptorExtractor extractor;
    cv::Mat des_object;
    
    extractor.compute( object, kp_object, des_object );
    
    cv::FlannBasedMatcher matcher;
    
    
    cv::namedWindow("Good Matches");
    
    std::vector<cv::Point2f> obj_corners(4);
    
    //Get the corners from the object
    obj_corners[0] = cvPoint(0,0);
    obj_corners[1] = cvPoint( object.cols, 0 );
    obj_corners[2] = cvPoint( object.cols, object.rows );
    obj_corners[3] = cvPoint( 0, object.rows );
    
    char key = 'a';
    int framecount = 0;
    while (key != 27)
    {
       
        
        if (framecount < 5)
        {
            framecount++;
            continue;
        }
        
        cv::Mat des_image, img_matches;
        std::vector<cv::KeyPoint> kp_image;
        std::vector<std::vector<cv::DMatch > > matches;
        std::vector<cv::DMatch > good_matches;
        std::vector<cv::Point2f> obj;
        std::vector<cv::Point2f> scene;
        std::vector<cv::Point2f> scene_corners(4);
        cv::Mat H;

        MyImage *sceneMyPic = new MyImage();
        sceneMyPic->setWidth(352);
        sceneMyPic->setHeight(288);
        sceneMyPic->setImagePath(argv[2]);
        sceneMyPic->ReadImage();

        cv::Mat image(Size(352, 288), CV_8UC3, sceneMyPic->getImageData());

        
        detector.detect( image, kp_image );
        extractor.compute( image, kp_image, des_image );
        
        matcher.knnMatch(des_object, des_image, matches, 2);
        
        for(int i = 0; i < cv::min(des_image.rows-1,(int) matches.size()); i++) //THIS LOOP IS SENSITIVE TO SEGFAULTS
        {
            if((matches[i][0].distance < 0.8*(matches[i][1].distance)) && ((int) matches[i].size()<=2 && (int) matches[i].size()>0))
            {
                good_matches.push_back(matches[i][0]);
            }
        }
        
        drawMatches( object, kp_object, image, kp_image, good_matches, img_matches, cv::Scalar::all(-1), cv::Scalar::all(-1), std::vector<char>(), cv::DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
        
        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;

}
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
 	// TODO: Place code here.
	MSG msg;
	HACCEL hAccelTable;

	int w, h;
	int quant = 0, coEff = 0;

	if(SQUARE == 1)
	{
		w = WIDTH;
		h = HEIGHT;
	}
	else if(RECTANGULAR == 1)
	{
		w = WIDTH;
		h = HEIGHT;
	}

	char ImagePath[_MAX_PATH];
	sscanf(lpCmdLine, "%s %d %d", &ImagePath, &quant, &coEff);

	if(SQUARE == 1)
	{
		w = 512;
		h = 512;
	}
	else if(RECTANGULAR == 1)
	{
		w = 352;
		h = 288;
	}

	myImage.setWidth(w);
	myImage.setHeight(h);
	myImage.setQuant(quant);
	myImage.setCoEff(coEff);
	myImage.setImagePath(ImagePath);
	
	myImage.FillInputRGBSpace();

	myImage.GrayScale2YUV();

	if(DCT_ACTIVE == 1)
		myImage.DCTBasedCompDecomp();

	if(IDCT_ACTIVE == 1)
	{
		remove("zigzag.txt");
		myImage.IDCTBasedCompDecomp();
	}

	myImage.YUV2RGB();
	
	if(TESTZIGZAG == 1)
	{
		remove("test.txt");
		myImage.TestZigTheZag();
	}

	// Initialize global strings
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_IMAGE, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_IMAGE);

	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return msg.wParam;
}
Пример #3
0
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
 	// TODO: Place code here.
	MSG msg;
	HACCEL hAccelTable;
	//prepare cos value table
	cosVal[0] = 1; cosVal[1] = cos(PI/16); cosVal[2] = cos(PI/8); cosVal[3] = cos((3*PI)/16);
	cosVal[4] = c; cosVal[5] = cos((5*PI)/16); cosVal[6] = cos((3*PI)/8); cosVal[7] = cos((7*PI)/16);
	cosVal[8] = 0; cosVal[9] = -sin(PI/16); cosVal[10] = -sin(PI/8); cosVal[11] = -sin((3*PI)/16);
	cosVal[12] = -c; cosVal[13] = -sin((5*PI)/16); cosVal[14] = -sin((3*PI)/8); cosVal[15] = -sin((7*PI)/16);

	for(int i = 0; i < 16; ++i){
		cosVal[i+16] = - cosVal[i];
	}

	int wd, ht;
	char ImagePath[_MAX_PATH];
	sscanf(lpCmdLine, "%s %d %d %d", &ImagePath, &quantizationLevel, &deliveryMode, &latency);
	
	if(quantizationLevel > 7 || quantizationLevel < 0){
		MessageBox(NULL, "Quantization Level can be 0 to 7 only.", NULL, NULL);
		return FALSE;
	}
	if(deliveryMode > 3 || deliveryMode < 1){
		MessageBox(NULL, "Delivery Mode can be either 1 2 or 3 only.", NULL, NULL);
		return FALSE;
	}
	if(latency < 0){
		MessageBox(NULL, "Latency can be greater than 0 only.", NULL, NULL);
		return FALSE;
	}

	wd=352; ht=288;	
	originalImage.setWidth(wd);
	originalImage.setHeight(ht);
	originalImage.setImagePath(ImagePath);
	originalImage.ReadImage();
	
	nextStart = wd + 50;
				
	workingImage.setHeight(ht);
	workingImage.setWidth(wd);
	
	Byte* imgd = new Byte[ht*wd*3];
	memset(imgd, 0xFF, sizeof(Byte)*ht*wd*3);
	
	workingImage.setImageData(imgd);
	imgd = NULL;
		
	// Initialize global strings
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_IMAGE, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow)) 
	{
		return FALSE;
	}	
	
	TwoByte *s = new TwoByte[ht*wd*3];
	MyStorage strg;
	strg.setStorage(s);
	encode(s);	

	if(deliveryMode == 1){
		_beginthread (sendDecodeSequentialMode, 0, s);	
	}
	else if(deliveryMode == 2){
		_beginthread (sendSpectralSelection, 0, s);
	}
	else if(deliveryMode == 3){
		_beginthread (sendSuccessiveBits, 0, s);
	}
	

	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_IMAGE);
	// Main message loop:
	while (GetMessage(&msg, NULL, 0, 0)) 
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
		
	return msg.wParam;
}