inline void ServerSiftGPU::ServerLoop(int port, int argc, char** argv)
{
SOCKET sockfd, newsockfd;
struct sockaddr_in serv_addr, cli_addr;
socklen_t addr_len = sizeof(sockaddr_in);
//////////////////////////////////////////////////
memset((char*)&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(port);
serv_addr.sin_addr.s_addr = INADDR_ANY;
/////////////////////////////////////////////
if(ServerSiftGPU::InitSocket() == 0)
{
return;
}
//////////////////////////////////////////////////////////////
sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd==INVALID_SOCKET)
{
std::cout << "server: can't open stream socket\n";
return;
}else if(bind(sockfd,(struct sockaddr*)&serv_addr, sizeof(serv_addr)))
{
std::cout << "server: can't bind to port " << port <<"\n";
return;
}else if(listen(sockfd, 1))
{
std::cout << "server: failed to listen\n";
return;
}else
{
std::cout << "server: listent to port "<< port << "\n";
}
newsockfd = accept(sockfd, (struct sockaddr*) &cli_addr, &addr_len);
if(newsockfd == INVALID_SOCKET)
{
std::cout << "error: accept failed\n";
closesocket(sockfd);
return;
}
////////////////////////////////////////////////////////////////
char buf[1024];
int command, result;
int sift_feature_count = 0;;
vector<SiftGPU::SiftKeypoint> keys;
vector<float> descriptors;
vector<char> databuf;
/////////////////////////////////////////////////////////////////
SiftGPU siftgpu;
SiftMatchGPU matcher;
if(argc > 0) siftgpu.ParseParam(argc, argv);
/////////////////////
siftgpu.SetVerbose(0);
/////////////////////////////////////////////////////////////////
do
{
while(SocketUtil::readint(newsockfd, &command) && command != COMMAND_DISCONNECT)
{
switch(command)
{
case COMMAND_INITIALIZE:
{
result = (siftgpu.CreateContextGL() == SiftGPU::SIFTGPU_FULL_SUPPORTED);
SocketUtil::writeint(newsockfd, result);
if(result) break;
}
case COMMAND_EXIT:
closesocket(newsockfd);
closesocket(sockfd);
return;
case COMMAND_ALLOCATE_PYRAMID:
{
int size[2];
SocketUtil::readint(newsockfd, size, 2);
if(size[0] > 0 && size[1] > 0) siftgpu.AllocatePyramid(size[0], size[1]);
break;
}
case COMMAND_GET_KEY_VECTOR:
{
int size = sift_feature_count * sizeof(SiftGPU::SiftKeypoint);
SocketUtil::writedata(newsockfd, &keys[0], size);
break;
}
case COMMAND_GET_DES_VECTOR:
{
int size = sift_feature_count * sizeof(float) * 128;
SocketUtil::writedata(newsockfd, &descriptors[0], size);
break;
}
case COMMAND_RUNSIFT:
{
result = siftgpu.RunSIFT();
if((sift_feature_count = siftgpu.GetFeatureNum()) > 0)
{
keys.resize(sift_feature_count);
descriptors.resize(sift_feature_count * 128);
siftgpu.GetFeatureVector(&keys[0], &descriptors[0]);
std::cout << "RunSIFT: [-] [" << sift_feature_count << "]\n";
}
SocketUtil::writeint(newsockfd, result);
break;
}
case COMMAND_RUNSIFT_FILE:
{
SocketUtil::readline(newsockfd, buf, 1024);
result = siftgpu.RunSIFT(buf);
if((sift_feature_count = siftgpu.GetFeatureNum()) > 0)
{
keys.resize(sift_feature_count);
descriptors.resize(sift_feature_count * 128);
siftgpu.GetFeatureVector(&keys[0], &descriptors[0]);
}
std::cout << "RunSIFT: "<< buf <<" " << sift_feature_count << "\n" ;
SocketUtil::writeint(newsockfd, result);
break;
}
case COMMAND_SET_KEYPOINT:
{
int keys_have_orientation;
SocketUtil::readint(newsockfd, &sift_feature_count);
SocketUtil::readint(newsockfd, &keys_have_orientation);
if(sift_feature_count > 0)
{
keys.resize(sift_feature_count);
descriptors.resize(sift_feature_count * 128);
SocketUtil::readdata(newsockfd, &keys[0], int(keys.size() * sizeof(SiftGPU::SiftKeypoint)));
siftgpu.SetKeypointList(sift_feature_count, &keys[0], keys_have_orientation);
}
break;
}
case COMMAND_RUNSIFT_KEY:
{
int keys_have_orientation;
SocketUtil::readint(newsockfd, &sift_feature_count);
SocketUtil::readint(newsockfd, &keys_have_orientation);
if(sift_feature_count > 0)
{
std::cout << "RunSIFT: "<< sift_feature_count << " KEYPOINTS\n" ;
int key_data_size = sift_feature_count * sizeof(SiftGPU::SiftKeypoint);
keys.resize(sift_feature_count);
descriptors.resize(sift_feature_count * 128);
SocketUtil::readdata(newsockfd, &keys[0], key_data_size);
result = siftgpu.RunSIFT(sift_feature_count, &keys[0], keys_have_orientation);
siftgpu.GetFeatureVector(NULL, &descriptors[0]);
}else
{
result = 0;
}
SocketUtil::writeint(newsockfd, result);
break;
}
case COMMAND_RUNSIFT_DATA:
{
int data_des[4], size = 0;
SocketUtil::readint(newsockfd, data_des, 4);
SocketUtil::readint(newsockfd, &size, 1);
std::cout << "RunSIFT: [" << data_des[0] << "x" << data_des[1] << "]";
databuf.resize(size);
void* data_ptr = &databuf[0];
SocketUtil::readdata(newsockfd, data_ptr, size);
result = siftgpu.RunSIFT(data_des[0], data_des[1], data_ptr, data_des[2], data_des[3]);
if((sift_feature_count = siftgpu.GetFeatureNum()) > 0)
{
keys.resize(sift_feature_count);
descriptors.resize(sift_feature_count * 128);
siftgpu.GetFeatureVector(&keys[0], &descriptors[0]);
}
std::cout << "[" << sift_feature_count << "]\n";
SocketUtil::writeint(newsockfd, result);
break;
}
case COMMAND_SAVE_SIFT:
{
SocketUtil::readline(newsockfd, buf, 1024);
siftgpu.SaveSIFT(buf);
break;
}
case COMMAND_SET_MAX_DIMENSION:
{
int maxd;
if(SocketUtil::readint(newsockfd, &maxd) && maxd > 0) siftgpu.SetMaxDimension(maxd);
break;
}
case COMMAND_SET_TIGHTPYRAMID:
{
int tight;
if(SocketUtil::readint(newsockfd, &tight)) siftgpu.SetTightPyramid(tight);
break;
}
case COMMAND_GET_FEATURE_COUNT:
{
SocketUtil::writeint(newsockfd, sift_feature_count);
break;
}
case COMMAND_PARSE_PARAM:
{
SocketUtil::readline(newsockfd, buf, 1024);
std::cout << "ParseParam [" << buf << "]\n";
vector<char*> params;
char* p = buf;
while(*p)
{
while(*p == ' ' || *p == '\t')*p++ = 0;
params.push_back(p);
while(*p && *p != ' ' && *p != '\t') p++;
}
siftgpu.ParseParam(params.size(), ¶ms[0]);
break;
}
case COMMAND_MATCH_INITIALIZE:
{
result = matcher.CreateContextGL();
SocketUtil::writeint(newsockfd, result);
break;
}
case COMMAND_MATCH_SET_LANGUAGE:
{
int language;
if(SocketUtil::readint(newsockfd, &language)) matcher.SetLanguage(language);
break;
}
case COMMAND_MATCH_SET_DES_FLOAT:
{
int command[3] = {0, 0, 0};
if(SocketUtil::readdata(newsockfd, command, sizeof(command)))
{
databuf.resize(sizeof(float) * 128 * command[1]);
if(SocketUtil::readdata(newsockfd, &databuf[0], databuf.size()))
{
matcher.SetDescriptors(command[0], command[1], (float*) (&databuf[0]), command[2]);
}
}
break;
}
case COMMAND_MATCH_SET_DES_BYTE:
{
int command[3] = {0, 0, 0};
if(SocketUtil::readdata(newsockfd, command, sizeof(command)))
{
databuf.resize(sizeof(unsigned char) * 128 * command[1]);
if(SocketUtil::readdata(newsockfd, &databuf[0], databuf.size()))
{
matcher.SetDescriptors(command[0], command[1], (unsigned char*) (&databuf[0]), command[2]);
}
}
break;
}
case COMMAND_MATCH_GET_MATCH:
{
int command[2]; float fcommand[2];
result = 0;
if( SocketUtil::readdata(newsockfd, command, sizeof(command)) &&
SocketUtil::readdata(newsockfd, fcommand, sizeof(fcommand)))
{
int max_match = command[0], mbm = command[1];
float distmax = fcommand[0], ratiomax = fcommand[1];
databuf.resize(max_match * 2 * sizeof(int));
result = matcher.GetSiftMatch(max_match, ( int(*)[2]) (&databuf[0]), distmax, ratiomax, mbm);
}
SocketUtil::writeint(newsockfd, result);
if(result > 0) SocketUtil::writedata(newsockfd, &databuf[0], sizeof(int) * 2 * result);
std::cout << "SiftMatch: " << result << "\n";
break;
}
case COMMAND_MATCH_SET_MAXSIFT:
{
int max_sift;
if(SocketUtil::readint(newsockfd, &max_sift)) matcher.SetMaxSift(max_sift);
break;
}
break;
default:
std::cout << "unrecognized command: " << command << "\n";
break;
}
}
//client disconneted
closesocket(newsockfd);
//wait for the next client.
std::cout << "wait for new client...";
newsockfd = accept(sockfd, (struct sockaddr*) &cli_addr, &addr_len);
if(newsockfd == INVALID_SOCKET)
{
std::cout << "error: accept failed";
closesocket(sockfd);
return;
}else
{
std::cout << "connected\n\n";
}
}while(1);
}
/***Method 1, set new keypoints for the image you've just processed with siftgpu*/
void LoadMyKeyPoints1(SiftGPU& sift, vector<SiftGPU::SiftKeypoint>& keys2, int num2, vector<SiftGPU::SiftKeypoint>& mykeys)
{
sift.RunSIFT(mykeys.size(),&mykeys[0]);
sift.RunSIFT(num2,&keys2[0],1);
sift.SaveSIFT("../640-1.sift.2");
sift.RunSIFT(num2,&keys2[0],0);
sift.SaveSIFT("../640-1.sift.3");
}
int main(int argc, char * argv[])
{
#ifdef SIFTGPU_DLL_RUNTIME
#ifdef _WIN32
#ifdef _DEBUG
HMODULE hsiftgpu = LoadLibrary("siftgpu_d.dll");
#else
HMODULE hsiftgpu = LoadLibrary("siftgpu.dll");
#endif
#else
void * hsiftgpu = dlopen("../bin/libsiftgpu.so", RTLD_LAZY);
#endif
if(hsiftgpu == NULL) return 0;
#ifdef REMOTE_SIFTGPU
ComboSiftGPU* (*pCreateRemoteSiftGPU) (int, char*) = NULL;
pCreateRemoteSiftGPU = (ComboSiftGPU* (*) (int, char*)) GET_MYPROC(hsiftgpu, "CreateRemoteSiftGPU");
ComboSiftGPU * combo = pCreateRemoteSiftGPU(REMOTE_SERVER_PORT, REMOTE_SERVER);
SiftGPU* sift = combo;
SiftMatchGPU* matcher = combo;
#else
SiftGPU* (*pCreateNewSiftGPU)(int) = NULL;
SiftMatchGPU* (*pCreateNewSiftMatchGPU)(int) = NULL;
pCreateNewSiftGPU = (SiftGPU* (*) (int)) GET_MYPROC(hsiftgpu, "CreateNewSiftGPU");
pCreateNewSiftMatchGPU = (SiftMatchGPU* (*)(int)) GET_MYPROC(hsiftgpu, "CreateNewSiftMatchGPU");
SiftGPU* sift = pCreateNewSiftGPU(1);
SiftMatchGPU* matcher = pCreateNewSiftMatchGPU(4096);
#endif
#elif defined(REMOTE_SIFTGPU)
ComboSiftGPU * combo = CreateRemoteSiftGPU(REMOTE_SERVER_PORT, REMOTE_SERVER);
SiftGPU* sift = combo;
SiftMatchGPU* matcher = combo;
#else
//this will use overloaded new operators
SiftGPU *sift = new SiftGPU;
SiftMatchGPU *matcher = new SiftMatchGPU(4096);
#endif
vector<float > descriptors1(1), descriptors2(1);
vector<SiftGPU::SiftKeypoint> keys1(1), keys2(1);
int num1 = 0, num2 = 0;
float start,all;
char * argw[] = {"-fo", "-1", "-v", "0","-t","0.03","-cuda","0","-maxd","3200"};
string directory=argv[1]; //"../../../Rendimiento/Imagenes/Imagenes_2";
vector<string> images;
vector<string> detections;
const string slash = "/";
if(listFilesDirectory(images, directory))
{
cout << "ERROR:finish Main"<<"\n" <<endl;
return -1;
}
for(unsigned int i=0; i < images.size(); i++)
{
int lastindex = images[i].find_last_of(".");
string imagesPath = directory + slash + images[i];
string outputPath = images[i].substr(images[i].rfind("/")+1,lastindex).append(".sift");
string detectsPath = directory + slash + outputPath;
detections.push_back(detectsPath);
images[i] = imagesPath;
}
int argd = sizeof(argw)/sizeof(char*);
sift->ParseParam(argd, argw);
if(sift->CreateContextGL() != SiftGPU::SIFTGPU_FULL_SUPPORTED) return 0;
//start=(float)getMilliSecond();
for(unsigned int i=0; i < images.size(); i++)
{
const char * imgPath = images[i].c_str();
sift->RunSIFT(imgPath);
sift->RunSIFT(num2, &keys2[0], 0);
string siftStr = detections[i];
const char * siftPath =siftStr.c_str();
sift->SaveSIFT(siftPath);
}
//getHumanReadableTime(start);
}
