/** @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;
}
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;
}
