/* Top level routine. Read PGM images and keypoints from files given
in command line arguments, then call FindMatches.
*/
int main (int argc, char **argv)
{
int arg = 0;
Image im1 = NULL, im2 = NULL;
Keypoint k1 = NULL, k2 = NULL;
/* Parse command line arguments and read given files. The command
line must specify two input images and two files of keypoints
using command line arguments as follows:
match -im1 i1.pgm -k1 k1.key -im2 i2.pgm -k2 k2.key > result.v
*/
while (++arg < argc) {
if (! strcmp(argv[arg], "-im1"))
im1 = ReadPGMFile(argv[++arg]);
else if (! strcmp(argv[arg], "-im2"))
im2 = ReadPGMFile(argv[++arg]);
else if (! strcmp(argv[arg], "-k1"))
k1 = ReadKeyFile(argv[++arg]);
else if (! strcmp(argv[arg], "-k2"))
k2 = ReadKeyFile(argv[++arg]);
else
FatalError("Invalid command line argument: %s", argv[arg]);
}
if (im1 == NULL || im2 == NULL || k1 == NULL || k2 == NULL)
FatalError("Command line does not specify all images and keys.");
FindMatches(im1, k1, im2, k2);
exit(0);
}
INT EncKeyInfo(
const CHAR * PrivateKey
)
{
CHAR * Pass = NULL;
PCRYPT_CONTEXT Context = NULL;
INT Ret = -1;
if((Pass = AskPass(CHECK_PASS, "Enter the password for the key:", NULL)) == NULL)
goto err;
if((Context = ReadKeyFile(PrivateKey, Pass)) == NULL) {
goto err;
}
DumpKey(&Context->key);
PrintMessage("%s\n", "EncKeyInfo: success!");
Ret = 0;
err:
if(NULL != Pass) {
free(Pass);
Pass = NULL;
}
if(NULL != Context) {
free(Context);
Context = NULL;
}
return Ret;
}
unsigned char *ReadAndFilterKeys(const char *keyfile, int dim,
double min_feature_scale,
int max_keys, int &num_keys_out)
{
short int *keys;
keypt_t *info = NULL;
int num_keys = ReadKeyFile(keyfile, &keys, &info);
if (num_keys == 0) {
num_keys_out = 0;
return NULL;
}
/* Filter keys */
unsigned char *keys_char = new unsigned char[num_keys * dim];
int num_keys_filtered = 0;
if (min_feature_scale == 0.0 && max_keys == 0) {
for (int j = 0; j < num_keys * dim; j++) {
keys_char[j] = (unsigned char) keys[j];
}
num_keys_filtered = num_keys;
} else {
for (int j = 0; j < num_keys; j++) {
if (info[j].scale < min_feature_scale)
continue;
for (int k = 0; k < dim; k++) {
keys_char[num_keys_filtered * dim + k] =
(unsigned char) keys[j * dim + k];
}
num_keys_filtered++;
if (max_keys > 0 && num_keys_filtered >= max_keys)
break;
}
}
delete [] keys;
if (info != NULL)
delete [] info;
num_keys_out = num_keys_filtered;
return keys_char;
}
/* Read in a set of keys from a file
*
* Inputs:
* keyfile : file from which to read keys
* dim : dimensionality of descriptors
*
* Outputs:
* num_keys_out : number of keys read
*
* Return value : pointer to array of descriptors. The descriptors
* are concatenated together in one big array of
* length num_keys_out * dim
*/
unsigned char *ReadKeys(const char *keyfile, int dim, int &num_keys_out)
{
short int *keys;
keypt_t *info = NULL;
int num_keys = ReadKeyFile(keyfile, &keys, &info);
unsigned char *keys_char = new unsigned char[num_keys * dim];
for (int j = 0; j < num_keys * dim; j++) {
keys_char[j] = (unsigned char) keys[j];
}
delete [] keys;
if (info != NULL)
delete [] info;
num_keys_out = num_keys;
return keys_char;
}
INT EncDiskDecrypt(const CHAR * FileName, const CHAR * PrivateKey, INT ThreadNum)
{
PCRYPT_CONTEXT Context = NULL;
CHAR * Pass = NULL;
HANDLE hFile = INVALID_HANDLE_VALUE;
LARGE_INTEGER FileSize;
INT Ret = -1;
if((Pass = AskPass(CHECK_PASS, "Enter the password for the key:", NULL)) == NULL)
goto err;
if((Context = ReadKeyFile(PrivateKey, Pass)) == NULL) {
goto err;
}
// open file
hFile = CreateFile(
FileName,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
NULL
);
if(hFile == INVALID_HANDLE_VALUE) {
PrintLastError("EncDiskDecrypt:");
goto err;
}
if(!GetFileSizeEx(hFile, &FileSize)) {
PrintLastError("EncDiskDecrypt:");
goto err;
}
CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
// file size should be n * CRYPT_CLUSTER_SIZE
if(FileSize.QuadPart % CRYPT_CLUSTER_SIZE != 0) {
PrintMessage("%s\n", "EncDiskDecrypt: invalid disk image");
goto err;
}
if(ProcessFile(FileName, Context, NULL, ThreadNum)!= 0) {
goto err;
}
Ret = 0;
PrintMessage("%s\n", "EncDiskDecrypt: success!");
err:
if(NULL != Pass) {
free(Pass);
Pass = NULL;
}
if(NULL != Context) {
free(Context);
Context = NULL;
}
if(INVALID_HANDLE_VALUE != hFile) {
CloseHandle(hFile);
hFile = INVALID_HANDLE_VALUE;
}
return Ret;
}
int main(int argc, char **argv) {
char *list_in;
char *file_out;
double ratio;
if (argc != 3 && argc != 4) {
printf("Usage: %s <list.txt> <outfile> [window_radius]\n", argv[0]);
return EXIT_FAILURE;
}
list_in = argv[1];
ratio = 0.6;
file_out = argv[2];
int window_radius = -1;
if (argc == 4) {
window_radius = atoi(argv[3]);
}
clock_t start = clock();
/* Read the list of files */
std::vector<std::string> key_files;
if (ReadFileList(list_in, key_files) != 0) return EXIT_FAILURE;
FILE *f;
if ((f = fopen(file_out, "w")) == NULL) {
printf("Could not open %s for writing.\n", file_out);
return EXIT_FAILURE;
}
int num_images = (int) key_files.size();
std::vector<unsigned char*> keys(num_images);
std::vector<int> num_keys(num_images);
/* Read all keys */
for (int i = 0; i < num_images; i++) {
keys[i] = NULL;
num_keys[i] = ReadKeyFile(key_files[i].c_str(), &keys[i]);
}
clock_t end = clock();
printf("[KeyMatchFull] Reading keys took %0.3fs\n",
(end - start) / ((double) CLOCKS_PER_SEC));
for (int i = 0; i < num_images; i++) {
if (num_keys[i] == 0)
continue;
printf("[KeyMatchFull] Matching to image %d\n", i);
start = clock();
/* Create a tree from the keys */
ANNkd_tree *tree = CreateSearchTree(num_keys[i], keys[i]);
/* Compute the start index */
int start_idx = 0;
if (window_radius > 0)
start_idx = std::max(i - window_radius, 0);
for (int j = start_idx; j < i; j++) {
if (num_keys[j] == 0)
continue;
/* Compute likely matches between two sets of keypoints */
std::vector<KeypointMatch> matches =
MatchKeys(num_keys[j], keys[j], tree, ratio);
int num_matches = (int) matches.size();
if (num_matches >= 16) {
/* Write the pair */
fprintf(f, "%d %d\n", j, i);
/* Write the number of matches */
fprintf(f, "%d\n", (int) matches.size());
for (int i = 0; i < num_matches; i++) {
fprintf(f, "%d %d\n",
matches[i].m_idx1, matches[i].m_idx2);
}
}
}
end = clock();
printf("[KeyMatchFull] Matching took %0.3fs\n",
(end - start) / ((double) CLOCKS_PER_SEC));
fflush(stdout);
delete tree;
}
/* Free keypoints */
for (int i = 0; i < num_images; i++) {
if (keys[i] != NULL)
delete [] keys[i];
}
fclose(f);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
if (argc != 6) {
printf("Usage: %s <list.in> <depth> <branching_factor> "
"<restarts> <tree.out>\n", argv[0]);
return 1;
}
const char *list_in = argv[1];
int depth = atoi(argv[2]);
int bf = atoi(argv[3]);
int restarts = atoi(argv[4]);
const char *tree_out = argv[5];
printf("Building tree with depth: %d, branching factor: %d, "
"and restarts: %d\n", depth, bf, restarts);
FILE *f = fopen(list_in, "r");
if (f == NULL) {
printf("Could not open file: %s\n", list_in);
return 1;
}
std::vector<std::string> key_files;
char buf[256];
while (fgets(buf, 256, f)) {
/* Remove trailing newline */
if (buf[strlen(buf) - 1] == '\n')
buf[strlen(buf) - 1] = 0;
key_files.push_back(std::string(buf));
}
fclose(f);
int num_files = (int) key_files.size();
unsigned long total_keys = 0;
for (int i = 0; i < num_files; i++) {
int num_keys = GetNumberOfKeys(key_files[i].c_str());
total_keys += num_keys;
}
printf("Total number of keys: %lu\n", total_keys);
// Reduce the branching factor if need be if there are not
// enough keys, to avoid problems later.
if (bf >= (int)total_keys){
bf = total_keys - 1;
printf("Reducing the branching factor to: %d\n", bf);
}
fflush(stdout);
int dim = 128;
unsigned long long len = (unsigned long long) total_keys * dim;
int num_arrays =
len / MAX_ARRAY_SIZE + ((len % MAX_ARRAY_SIZE) == 0 ? 0 : 1);
unsigned char **vs = new unsigned char *[num_arrays];
printf("Allocating %llu bytes in total, in %d arrays\n", len, num_arrays);
unsigned long long total = 0;
for (int i = 0; i < num_arrays; i++) {
unsigned long long remainder = len - total;
unsigned long len_curr = MIN(remainder, MAX_ARRAY_SIZE);
printf("Allocating array of size %lu\n", len_curr);
fflush(stdout);
vs[i] = new unsigned char[len_curr];
remainder -= len_curr;
}
/* Create the array of pointers */
printf("Allocating pointer array of size %lu\n", 4 * total_keys);
fflush(stdout);
unsigned char **vp = new unsigned char *[total_keys];
unsigned long off = 0;
unsigned long curr_key = 0;
int curr_array = 0;
for (int i = 0; i < num_files; i++) {
printf(" Reading keyfile %s\n", key_files[i].c_str());
fflush(stdout);
short int *keys;
int num_keys = 0;
keypt_t *info = NULL;
num_keys = ReadKeyFile(key_files[i].c_str(), &keys);
if (num_keys > 0) {
for (int j = 0; j < num_keys; j++) {
for (int k = 0; k < dim; k++) {
vs[curr_array][off + k] = keys[j * dim + k];
}
vp[curr_key] = vs[curr_array] + off;
curr_key++;
off += dim;
if (off == MAX_ARRAY_SIZE) {
off = 0;
curr_array++;
}
}
delete [] keys;
if (info != NULL)
delete [] info;
}
}
VocabTree tree;
tree.Build(total_keys, dim, depth, bf, restarts, vp);
tree.Write(tree_out);
return 0;
}
int main(int argc, char** argv)
{
char *im_file = 0;
char *feat_file = 0;
char *out_file= 0;
int nDir = 8, nOrder = 6, nMultiRegion = 4;
int m_Dim = nDir * nOrder * nMultiRegion;
int counter = 1;
while( counter < argc )
{
if( !strcmp("-i", argv[counter] ))
{
im_file = argv[++counter];
counter++;
continue;
}
if( !strcmp("-f", argv[counter] ))
{
feat_file = argv[++counter];
counter++;
continue;
}
if( !strcmp("-o", argv[counter] ))
{
out_file = argv[++counter];
counter++;
continue;
}
if( !strcmp("-Dir", argv[counter] ) )
{
nDir = atoi(argv[++counter]);
counter++;
continue;
}
if( !strcmp("-Order", argv[counter] ) )
{
nOrder = atoi(argv[++counter]);
counter++;
continue;
}
if( !strcmp("-R", argv[counter] ) )
{
nMultiRegion = atoi(argv[++counter]);
counter++;
continue;
}
exit(1);
}
/* do the job */
m_Dim = nDir * nOrder * nMultiRegion;
clock_t start,final;
start = clock();
int m_nKeys = 0;
OxKey *m_pKeys = ReadKeyFile(feat_file,m_nKeys);
CalcuTrans(m_pKeys,m_nKeys);
IplImage* m_pImg = cvLoadImage(im_file,CV_LOAD_IMAGE_GRAYSCALE);
cvSmooth(m_pImg,m_pImg,CV_GAUSSIAN,5,5,1);
FILE *fid = fopen(out_file,"wt");
fprintf(fid,"%d\n%d\n",m_Dim,m_nKeys);
int i;
for (i = 0;i < m_nKeys;i++)
{
int *desc = 0;
desc = Extract_MROGH(m_pKeys[i],m_pImg,nDir,nOrder,nMultiRegion);
if ( !desc ) continue;
fprintf(fid,"%f %f %f %f %f",m_pKeys[i].x,m_pKeys[i].y,m_pKeys[i].a,m_pKeys[i].b,m_pKeys[i].c);
for (int j = 0;j < m_Dim;j++)
{
fprintf(fid," %d",desc[j]);
}
fprintf(fid,"\n");
delete [] desc;
}
fclose(fid);
final = clock();
int main(int argc, char **argv) {
char *list_in;
char *file_out;
double ratio;
if (argc != 3) {
printf("Usage: %s <list.txt> <outfile>\n", argv[0]);
return -1;
}
list_in = argv[1];
ratio = 0.6;
file_out = argv[2];
clock_t start = clock();
unsigned char **keys;
int *num_keys;
/* Read the list of files */
std::vector<std::string> key_files;
FILE *f = fopen(list_in, "r");
if (f == NULL) {
printf("Error opening file %s for reading\n", list_in);
return 1;
}
char buf[512];
while (fgets(buf, 512, f)) {
/* Remove trailing newline */
if (buf[strlen(buf) - 1] == '\n')
buf[strlen(buf) - 1] = 0;
key_files.push_back(std::string(buf));
}
fclose(f);
f = fopen(file_out, "w");
assert(f != NULL);
int num_images = (int) key_files.size();
keys = new unsigned char *[num_images];
num_keys = new int[num_images];
/* Read all keys */
for (int i = 0; i < num_images; i++) {
keys[i] = NULL;
num_keys[i] = ReadKeyFile(key_files[i].c_str(), keys+i);
}
clock_t end = clock();
printf("[KeyMatchFull] Reading keys took %0.3fs\n",
(end - start) / ((double) CLOCKS_PER_SEC));
for (int i = 0; i < num_images; i++) {
if (num_keys[i] == 0)
continue;
printf("[KeyMatchFull] Matching to image %d\n", i);
start = clock();
/* Create a tree from the keys */
ANNkd_tree *tree = CreateSearchTree(num_keys[i], keys[i]);
for (int j = 0; j < i; j++) {
if (num_keys[j] == 0)
continue;
/* Compute likely matches between two sets of keypoints */
std::vector<KeypointMatch> matches =
MatchKeys(num_keys[j], keys[j], tree, ratio);
int num_matches = (int) matches.size();
if (num_matches >= 16) {
/* Write the pair */
fprintf(f, "%d %d\n", j, i);
/* Write the number of matches */
fprintf(f, "%d\n", (int) matches.size());
for (int i = 0; i < num_matches; i++) {
fprintf(f, "%d %d\n",
matches[i].m_idx1, matches[i].m_idx2);
}
}
}
end = clock();
printf("[KeyMatchFull] Matching took %0.3fs\n",
(end - start) / ((double) CLOCKS_PER_SEC));
fflush(stdout);
// annDeallocPts(tree->pts);
delete tree;
}
/* Free keypoints */
for (int i = 0; i < num_images; i++) {
if (keys[i] != NULL)
delete [] keys[i];
}
delete [] keys;
delete [] num_keys;
fclose(f);
return 0;
}
