SPConfig getConfigFromFile(const char* configFilename, SP_CONFIG_MSG* msg) {
SPConfig config;
config = spConfigCreate(configFilename, msg);
if (*msg == SP_CONFIG_CANNOT_OPEN_FILE)
printf(CANNOT_OPEN_MSG, configFilename);
return config;
}
int main(char * args){
//Make sure that the logger was set at the beginning of the main function
//start
// COMMAND LINE ARGUMENT with the Error messages
char * configFilename;
if (args == NULL){
configFilename = "spcbir.config";
}
else{
configFilename = args;
}
//“Invalid command line : use -c <config_filename>” - check
//init from config
SP_CONFIG_MSG spConfigMsg;
SPConfig configFile = spConfigCreate(configFilename,spConfigMsg); //should destroy it
if (spConfigMsg == SP_CONFIG_CANNOT_OPEN_FILE){
if (configFilename == "spcbir.config" ){
//“The default configuration file spcbir.config couldn’t be open” +new line + exit?
}
else{
//#2 “The configuration file <filename> couldn’t be open” + new line +exit?
}
}
//variables
int NumOfImages = spConfigGetNumOfImages(configFile,spConfigMsg);
char * imagePath =(char*) malloc (1024*sizeof(char)); // should free it
int spKNN = spConfigGetspKNN(configFile,spConfigMsg);
int NumOfFeatures = spConfigGetNumOfFeatures(configFile,spConfigMsg);
int * imgArray = (int*)malloc (sizeof(int)*configFile,spConfigMsg); // should free it
int NumOfSimilarImages=spConfigGetNumOfSimilarImages(configFile,spConfigMsg);
int * SimilarImagesArr = (int*)malloc (NumOfSimilarImages*sizeof(int)); // should free it
int i=0;
for (i=0;i<NumOfSimilarImages;i++){
SimilarImagesArr[i]=0;
}
i=0;
for (i=0; i<NumOfImages;i++){
imgArray[i]=0;
}
i=0;
SPPoint * queryFeatures = (SPPoint*) malloc (NumOfFeatures*sizeof (SPPoint)); // should free it
char * queryImgPath =(char*) malloc (1024*sizeof(char)); // should free it
int max=0;
int j=0;
// extract mode?
if (spConfigIsExtractionMode(configFile,spConfigMsg)){
// yes:
//extract features
// done?
// no: repeat
// yes: save to directory
}
else{
//no:
// extract from file
}
// init data structures
// recive command
// query?
query:
printf("Please enter an image path:\n");
scanf("%s", queryImgPath);
// no: exit
if (queryImgPath== '<>'){
goto ending;
}
// get query features
queryFeatures = getImageFeatures(queryImgPath,int index,int* numOfFeats);
for (i=0;i<NumOfFeatures;i++){
spKNNSearch( tree, queryFeatures[i], spKNN, imgArray);
}
i=0;
// get most similar images
for (i=0;i<NumOfSimilarImages;i++){
for (j=0;j<NumOfFeatures;j++){
if (imgArray[j]>imgArray[max]){
max = j;
}
}
SimilarImagesArr[i]= max;
imgArray[max] =-1;
}
i=0;
// show results
if(spConfigMinimalGui(configFile,spConfigMsg)){
for (i=0;i<NumOfSimilarImages;i++){
spConfigGetImagePath(imagePath, configFile, SimilarImagesArr[i]);
showImage(imagePath);
//wait
}
}
else{
printf("Best candidates for - %d - are:\n",queryImgPath);
for (i=0;i<NumOfSimilarImages;i++){
spConfigGetImagePath(imagePath, configFile, SimilarImagesArr[i]);
printf ("%d\n",imagePath);
}
}
goto query;
ending:
// ending
//frees ();
spConfigDestroy (configFilename);
free (imagePath);
free (SimilarImagesArr);
free (queryFeatures);
free (queryImgPath);
free (imgArray);
return 0;
};
bool testGivenConfFile() {
char imagePath[100], pcaPath[100];
SP_CONFIG_MSG msg = SP_CONFIG_SUCCESS;
SPConfig config = spConfigCreate("./unit_tests/spcbirTestCase1.config", &msg);
ASSERT_TRUE(config != NULL);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(!strcmp(spConfigGetImagesDirectory(config, &msg), "./images/"));
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetImagesDirectory(NULL, &msg) == NULL);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(!strcmp(spConfigGetImagesPrefix(config, &msg), "img"));
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetImagesPrefix(NULL, &msg) == NULL);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(!strcmp(spConfigGetImagesSuffix(config, &msg), ".png"));
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetImagesSuffix(NULL, &msg) == NULL);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(!strcmp(spConfigGetPCAFilename(config, &msg), "pca.yml"));
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetPCAFilename(NULL, &msg) == NULL);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigIsExtractionMode(config, &msg) == true);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigIsExtractionMode(NULL, &msg) == false);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigMinimalGui(config, &msg) == false);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigMinimalGui(NULL, &msg) == false);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetNumOfImages(config, &msg) == 22);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetNumOfImages(NULL, &msg) == -1);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetNumOfFeatures(config, &msg) == 100);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetNumOfFeatures(NULL, &msg) == -1);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetPCADim(config, &msg) == 20);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetPCADim(NULL, &msg) == -1);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetNumOfSimilarImages(config, &msg) == 5);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetNumOfSimilarImages(NULL, &msg) == -1);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetKNN(config, &msg) == 5);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetKNN(NULL, &msg) == -1);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetSplitMethod(config, &msg) == MAX_SPREAD);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetSplitMethod(NULL, &msg) == MAX_SPREAD);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetLoggerLevel(config, &msg) == SP_LOGGER_DEBUG_INFO_WARNING_ERROR_LEVEL);
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetLoggerLevel(NULL, &msg) == SP_LOGGER_INFO_WARNING_ERROR_LEVEL);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(!strcmp(spConfigGetLoggerFilename(config, &msg), "stdout"));
ASSERT_TRUE(msg == SP_CONFIG_SUCCESS);
ASSERT_TRUE(spConfigGetLoggerFilename(NULL, &msg) == NULL);
ASSERT_TRUE(msg == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetImagePath(imagePath, config, 13) == SP_CONFIG_SUCCESS);
ASSERT_TRUE(!strcmp(imagePath, "./images/img13.png"));
ASSERT_TRUE(spConfigGetImagePath(imagePath, config, 22) == SP_CONFIG_INDEX_OUT_OF_RANGE);
ASSERT_TRUE(spConfigGetImagePath(NULL, config, 1) == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetImagePath(imagePath, NULL, 1) == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetImagePath(NULL, NULL, 1) == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetPCAPath(pcaPath, config) == SP_CONFIG_SUCCESS);
ASSERT_TRUE(!strcmp(pcaPath, "./images/pca.yml"));
ASSERT_TRUE(spConfigGetPCAPath(NULL, config) == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetPCAPath(pcaPath, NULL) == SP_CONFIG_INVALID_ARGUMENT);
ASSERT_TRUE(spConfigGetPCAPath(NULL, NULL) == SP_CONFIG_INVALID_ARGUMENT);
spConfigDestroy(config);
return true;
}
bool runConfigTest(CONFIG_TEST_TYPE testType, int fileIndex, int expectedLine , SPConfig * config)
{
SP_CONFIG_MSG msg;
char fileName[50] = {0};
char expectedStr[50];
spLoggerCreate(LOG_FILE_NAME, SP_LOGGER_DEBUG_INFO_WARNING_ERROR_LEVEL);
switch(testType)
{
case FAIL_CONSTRAINT:
{
getNextConfigConstraintPath(fileIndex, fileName);
sprintf(expectedStr, "Constraint: %d" , expectedLine);
break;
}
case FAIL_INVALID_LINE:
{
getNextConfigInvalidLinePath(fileIndex, fileName);
sprintf(expectedStr, "Invalid line: %d" , expectedLine);
break;
}
case FAIL_PARAMETER_NOT_SET:
{
getNextConfigParameterNotSetPath(fileIndex, fileName);
char nonDefaultFieldName[MAX_NONDEFAULT_FIELD_NAME_LEN];
switch(expectedLine)
{
case 1:
{
strcpy(nonDefaultFieldName, FIELD_NAME_ImgDir);
break;
}
case 2:
{
strcpy(nonDefaultFieldName, FIELD_NAME_ImgPre);
break;
}
case 3:
{
strcpy(nonDefaultFieldName, FIELD_NAME_ImgSuf);
break;
}
case 4:
{
strcpy(nonDefaultFieldName, FIELD_NAME_NumImg);
break;
}
default:
{
printf("Invalid non default parameter number (the options are 1-4)");
return false;
}
}
sprintf(expectedStr, "Non default: %s" , nonDefaultFieldName);
break;
}
case SUCCESS:
{
getNextConfigSuccessPath(fileIndex, fileName);
break;
}
}
*config = spConfigCreate(fileName, &msg);
/********************
* expected success *
********************/
if (testType == SUCCESS)
{
ASSERT_FALSE(NULL == *config);
spLoggerDestroy();
return true;
}
/******************
* expected error *
******************/
ASSERT_TRUE(NULL == *config);
spLoggerDestroy();
/* compare expected error to logged error s*/
return compareFirstLineWithStr(LOG_FILE_NAME, expectedStr);
}
int main(int argc, char *argv[]) {
SPConfig config = NULL; // hold configuration parameters
char config_filename[CONFIG_FILE_PATH_SIZE]; // the configuration file name
int knn; // the number of similar features in each image to find (spKNN from configuration file)
int num_of_similar_images_to_find; // the number of similar images (to the query) to find (from configuration file)
int split_method; // holds an int representing the split method: 0=RANDOM, 1= MAX_SPREAD, 2=INCREMENTAL
bool minGui = false; // value of the system variable MinimalGui
bool extraction_mode; // indicates if extraction mode on or off
int num_of_images = 0; // number of images in the directory given by the user in the configuration file
char** all_images_paths = NULL; // array with the paths to all the images
int last_extracted_feature = 0; // helper - holds the last feature extracted in order to free all extracted features on error
SPPoint** features_per_image = NULL; // helper - holds the features for each images
int* num_of_features_per_image = NULL; // holds number of features extracted for each image
char query_image[CONFIG_FILE_PATH_SIZE]; // the query image
SPPoint* query_features = NULL; // all query features
int query_num_of_features; // number of features in query image
KDTreeNode kd_tree = NULL; // array holds a KDTree for the images
int* closest_images = NULL; // array holds the spNumOfSimilarImages indexes of the closest images to the query image
int print_result; // holds the result of the call to PrintMinGuiFalse
int retval = 0; // return value - default 0 on success
char string_holder[CONFIG_FILE_PATH_SIZE]; // helper to hold strings
sp::ImageProc *improc = NULL;
SP_CONFIG_MSG msg;
int i;
int j;
int n;
// validate command line arguments:
// cmd line arguments are ok if there was no arguments specified (argc == 1) or two arguments specified ( -c and filname)
if (argc != 3 && argc != 1) {
printf(INVALID_CMD_LINE_MSG);
return -1;
}
if (argc == 1) {
strcpy(config_filename, DEFAULT_CONFIG_FILENAME);
config = spConfigCreate(config_filename, &msg);
if (msg == SP_CONFIG_CANNOT_OPEN_FILE) {
printf(ERROR_OPENING_DEFAULT_CONFIG_FILE_MSG, DEFAULT_CONFIG_FILENAME);
}
if (msg != SP_CONFIG_SUCCESS) {
retval = -1;
goto err; // error is printed inside spConfigCreate
}
}
else { // argc == 3
// check that second argument is the -c flag
if (strcmp(argv[1], CMD_LINE_CONFIG_FILENAME_FLAG) != 0) {
printf(INVALID_CMD_LINE_MSG);
retval = -1;
goto err;
}
strcpy(config_filename, argv[2]);
config = spConfigCreate(config_filename, &msg);
if (msg == SP_CONFIG_CANNOT_OPEN_FILE) {
printf(ERROR_OPENING_CONFIG_FILE_MSG, config_filename);
}
if (msg != SP_CONFIG_SUCCESS) {
retval = -1;
goto err; // error is printed inside spConfigCreate
}
}
// initiate from config
if (initFromConfig(config, &num_of_images, &num_of_similar_images_to_find, &knn, &split_method, &extraction_mode, &minGui, &all_images_paths) == -1 ) {
retval = -1;
goto err; // error is printed inside initFromConfig
}
// initiate image proc
improc = new sp::ImageProc(config);
// extract images features
if ((num_of_features_per_image = (int*)malloc(sizeof(*num_of_features_per_image) * num_of_images)) == NULL) {
spLoggerPrintError(ALLOCATION_FAILURE_MSG, __FILE__, __func__, __LINE__);
retval = -1;
goto err;
}
spLoggerPrintInfo(CHECK_EXTRACTION_MODE_INFO_LOG);
if (extraction_mode) { // extraction mode is chosen
spLoggerPrintMsg(USE_EXTRACTION_MODE_LOG);
spLoggerPrintInfo(EXTRACT_IMAGES_FEATURES_INFO_LOG);
if ((features_per_image = (SPPoint**)malloc(sizeof(*features_per_image) * num_of_images)) == NULL) {
spLoggerPrintError(ALLOCATION_FAILURE_MSG, __FILE__, __func__, __LINE__);
retval = -1;
goto err;
}
// extract each image features and write them to file
for (i=0; i < num_of_images; i++) {
// extract image features
if ((features_per_image[i] = improc->getImageFeatures(all_images_paths[i], i, &(num_of_features_per_image[i]))) == NULL) {
last_extracted_feature = i;
retval = -1;
goto err; // error is printed inside getImageFeatures
}
}
if (saveToDirectory(config, features_per_image, num_of_features_per_image, num_of_images) == -1) {
retval = -1;
goto err; // error is printed inside saveToDirectory
}
}
else { // not extraction mode
spLoggerPrintMsg(USE_NOT_EXTRACTION_MODE_LOG);
spLoggerPrintInfo(READ_FEATURES_FROM_FILE_LOG);
if ((features_per_image = extractFromFiles(config, num_of_features_per_image, num_of_images)) == NULL) {
retval = -1;
goto err; // error is printed inside extractFromFiles
}
}
if ((kd_tree = initiateDataStructures(features_per_image, num_of_features_per_image, num_of_images, split_method)) == NULL) {
retval = -1;
goto err; // error is printed inside initiateDataStructures
}
query:
while(1) {
// get a query image from the user
printf(ENTER_AN_IMAGE_MSG);
fflush(NULL);
scanf("%s",query_image);
// exit if user asked
if (strcmp (query_image,EXIT_SIGN) == 0) {
printf(EXIT_MSG);
fflush(NULL);
goto err; // free memory and quit
}
if( access( query_image, F_OK ) == -1 ) {
printf(FILE_DOESNT_EXIST, query_image);
goto query;
}
// extract query image features
spLoggerPrintMsg(EXTRACT_QUERY_IMAGE_FEATURES_LOG);
if ((query_features = improc->getImageFeatures(query_image, num_of_images, &query_num_of_features)) == NULL) {
retval = -1;
goto err_inside_loop; // error log is printed inside getImageFeatures
}
// print debug log
if ((n = sprintf(string_holder, NUM_OF_EXTRACTED_FEATURES_DEBUG_LOG, query_num_of_features)) < 0) {
spLoggerPrintError(GENERAL_ERROR_MSG, __FILE__, __func__, __LINE__);
retval = -1;
goto err_inside_loop;
}
spLoggerPrintDebug(string_holder, __FILE__, __func__, __LINE__);
// print log message
if ((n = sprintf(string_holder, SEARCING_SIMILAR_IMAGES_MSG, num_of_similar_images_to_find)) < 0) {
spLoggerPrintError(GENERAL_ERROR_MSG, __FILE__, __func__, __LINE__);
retval = -1;
goto err_inside_loop;
}
spLoggerPrintMsg(string_holder);
// find similar images to the query image
closest_images = getKClosestImages(num_of_similar_images_to_find, knn, query_features,
kd_tree, query_num_of_features, num_of_images);
if (closest_images == NULL) {
retval = -1;
goto err_inside_loop; // error is printed to inside getKClosestImages
}
// show (display) closest_images images
//need to show images
if (minGui==true){
for (i=0; i<num_of_similar_images_to_find; i++){
//get file path of the images by the indexes in closest_images
improc->showImage(all_images_paths[closest_images[i]]);
}
}
// i.e. minGui==false, just need to print images path
else{
print_result = PrintMinGuiFalse(query_image, num_of_similar_images_to_find, all_images_paths, closest_images);
if (print_result == 0) {
retval = -1;
goto err_inside_loop; // error is printed inside
}
}
// free memory before entering the loop again
free(closest_images);
if (query_features != NULL) {
for (i=0; i<query_num_of_features; i++) {
spPointDestroy(query_features[i]);
}
free(query_features);
}
}
err_inside_loop:
free(closest_images);
// free query_features
if (query_features != NULL) {
for (i=0; i<query_num_of_features; i++) {
spPointDestroy(query_features[i]);
}
free(query_features);
}
// done - destroy logger and free everything
err:
spLoggerDestroy();
// free the kd tree
DestroyKDTreeNode(kd_tree);
spConfigDestroy(config);
// free all images paths
if (all_images_paths != NULL) {
for (i = 0; i < num_of_images; i ++) {
free(all_images_paths[i]);
}
free(all_images_paths);
}
if (features_per_image != NULL) {
// free features_per_image
for (i = 0; i < last_extracted_feature; i ++) {
if (features_per_image[i] != NULL) {
for (j = 0; j < num_of_features_per_image[i]; j++) {
spPointDestroy(features_per_image[i][j]);
}
}
}
free(features_per_image);
}
free(num_of_features_per_image); // must be freed after features_per_image
if (improc != NULL) {
delete improc;
}
return retval;
}
/****
* The purpose of the test is to compare the features before and after the saving.
*/
bool main_saveLoad()
{
LoadedFeatures loadedFeatures = NULL;
LoadedFeatures features = NULL;
int numOfImages = 0;
int numOfFeatures = 0;
int numOfCoords = 0;
SPPoint * orgArr = NULL;
SPPoint pointOrg = NULL;
SPPoint * loadedArr = NULL;
SPPoint pointLoad = NULL;
SP_CONFIG_MSG msg;
char fileName[30] = "./tests/config/saveLoad.cfg";
SPConfig conf = spConfigCreate(fileName, &msg);
ASSERT_TRUE(NULL != conf);
/****
* Allocates, creates(by imageProc) and saves the features
****/
features = allocateFeaturesList(conf);
ASSERT_TRUE(NULL != features);
ASSERT_TRUE(true == debugSaveFeatures(conf, features));
/****
* Load the features from the files
*****/
loadedFeatures = allocateFeaturesList(conf);
ASSERT_TRUE(NULL != loadedFeatures);
ASSERT_TRUE(true == loadFeatures(conf, loadedFeatures));
/****************************************
* Compare original and loaded features *
****************************************/
ASSERT_TRUE(getFeaturesImagesNumber(features) ==
getFeaturesImagesNumber(loadedFeatures));
numOfImages = getFeaturesImagesNumber(features);
for (int index_image=0; index_image<numOfImages ; index_image++)
{
numOfFeatures = getFeaturesNumber(features, index_image);
ASSERT_TRUE(numOfFeatures == getFeaturesNumber(loadedFeatures, index_image));
for (int index_feature=0; index_feature<numOfFeatures ; index_feature++)
{
orgArr = getFeatureArray(features, index_image);
loadedArr = getFeatureArray(loadedFeatures, index_image);
pointOrg = orgArr[index_feature];
pointLoad = loadedArr[index_feature];
numOfCoords = spPointGetDimension(pointOrg);
ASSERT_TRUE(numOfCoords == spPointGetDimension(pointLoad));
ASSERT_TRUE(spPointGetIndex(pointOrg) == spPointGetIndex(pointLoad));
for (int index_coor=0; index_coor<numOfCoords ; index_coor++)
{
ASSERT_TRUE(spPointGetAxisCoor(pointOrg, index_coor) ==
spPointGetAxisCoor(pointLoad, index_coor));
}
}
}
loadedFeaturesDestroy(loadedFeatures);
loadedFeaturesDestroy(features);
return true;
}
