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);
}
int main(int argc, char * argv[])
{
#ifndef TEST_MULTI_PROCESS_SIFTGPU
SiftGPU sift;
#else
ComboSiftGPU* combo = CreateRemoteSiftGPU();
SiftGPU& sift = (*combo);
#endif
int num;
float timing[10], time_all =0, time_start;
//Parse parameters
sift.ParseParam(argc - 1, argv + 1);
sift.SetVerbose(0);
std::cout<<"Initialize and warm up...\n";
//create an OpenGL context for computation
if(sift.CreateContextGL() ==0) return 0;
if(sift.RunSIFT()==0) return 0;
//image is loaded for only once for this experiment
#ifndef TEST_MULTI_PROCESS_SIFTGPU
std::cout<<"Loading image: " << sift._timing[0]*1000 << "ms, "
<<"Tex initialization: "<<sift._timing[1]*1000 << "ms\n\n"
<<"Start 2x"<<SIFTGPU_REPEAT<<" repetitions...\n";
#ifdef INCLUDE_DISK_READING_TIME
char imagepath[MAX_PATH];
strcpy(imagepath, sift.GetCurrentImagePath());
#endif
#endif
//run one more time to get all texture allocated
sift.RunSIFT();
num = sift.GetFeatureNum();
//use no message output mode to get maximum speed.
time_start = (float) GetMilliSecond();
for(int i = 0; i < SIFTGPU_REPEAT; i++)
{
#ifdef INCLUDE_DISK_READING_TIME
sift.RunSIFT(imagepath);
#else
sift.RunSIFT();
#endif
if(sift.GetFeatureNum()==num) std::cout <<"+";
else std::cout << "e";
}
time_all = ((float)GetMilliSecond() - time_start)/1000/SIFTGPU_REPEAT;
std::cout<<"\n";
//change the timing setting, so that we can get more accurate timing for each steps
//in this mode, the overal speed will be decreased.
sift.SetVerbose(-2); //little trick to disable all output but keep the timing
std::fill(timing, timing + 10, 0.0f);
for(int k = 0; k < SIFTGPU_REPEAT; k++)
{
#ifdef INCLUDE_DISK_READING_TIME
sift.RunSIFT(imagepath);
#else
sift.RunSIFT();
#endif
for(int j = 0; j < 10; j++) timing[j] += sift._timing[j];
if(sift.GetFeatureNum()==num) std::cout <<"#";
else std::cout << "e";
}
for(int j = 0; j < 10; j++) timing[j] /= SIFTGPU_REPEAT;
std::cout
<<"\n\n****************************************\n"
<<"[Feature Count]:\t" << num << "\n"
<<"[Average Time]:\t\t" << time_all * 1000.0f << "ms\n"
<<"[Average Speed]:\t" << 1.0 / time_all << "hz\n"
#ifndef TEST_MULTI_PROCESS_SIFTGPU
#ifdef INCLUDE_DISK_READING_TIME
<<"[Load Image File]:\t" << timing[0] * 1000.0f << "ms\n"
#endif
<<"[Build Pyramid]:\t" << timing[2] * 1000.0f << "ms\n"
<<"[Detection]:\t\t" << timing[3] * 1000.0f << "ms\n"
<<"[Feature List]:\t\t" << timing[4] * 1000.0f << "ms\n"
<<"[Orientation]:\t\t" << timing[5] * 1000.0f << "ms\n"
<<"[MO Feature List]:\t" << timing[6] * 1000.0f << "ms\n"
<<"[Download Keys]:\t" << timing[7] * 1000.0f << "ms\n"
<<"[Descriptor]:\t\t" << timing[8] * 1000.0f << "ms\n"
#endif
<<"****************************************\n";
#ifdef TEST_MULTI_PROCESS_SIFTGPU
delete combo;
#endif
return 0;
}
