First CommitHEADmaster

1 files changed, 550 insertions, 0 deletions

diff --git a/sci_gateway1/cpp/opencv_bagOfFeatures.cpp b/sci_gateway1/cpp/opencv_bagOfFeatures.cpp
new file mode 100644
index 0000000..e87c40c
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_bagOfFeatures.cpp
@@ -0,0 +1,550 @@
+/****************************************************************************************************
+*	Author:	Umang Agrawal               																															*
+*	Code:		bagOfFeatues.cpp																																					*
+*	Function Format:	bag = bagOfFeatures(imageSet, Oprional Arguments Name, Value)							      *
+*					Arguments:				Name																Value																*
+*											1. VocabularySize							any integer value greater than 0								*
+*											2. StrongestFeatures					pecentage of best features to be Selected				*
+*											3. Upright										Bool 0 or 1																			*
+*											4. Verbose										Bool 0 or 1																			*
+****************************************************************************************************/
+
+#include <iostream>
+#include <numeric>
+#include <vector>
+#include <string>
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+
+using namespace cv;
+using namespace std;
+
+extern "C"
+{
+	#include "api_scilab.h"
+	#include "Scierror.h"
+	#include "BOOL.h"
+	#include <localization.h>
+	#include "sciprint.h"
+	#include "../common.h"
+
+  bool response_comparator(const KeyPoint& p1, const KeyPoint& p2) {
+      return p1.response > p2.response;
+  }
+
+	int opencv_bagOfFeatures(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+
+		int inp_params = 0;
+
+    int *piAddr = NULL;
+    int *piAddr1 = NULL;
+		int *piAddr2 = NULL;
+    int *piAddr3 = NULL;
+    int *piAddr4 = NULL;
+		int *piLen = NULL;
+		int *piChild = NULL;
+		char **pstData = NULL;
+		int iRows, iCols;
+		char **arg = NULL;
+		int count_ver = 0, count_up = 0, count_strength = 0, count_vocab = 0;
+
+		int descriptionCount;
+		char *objectType = "bagOfFeatures";
+		char **description = NULL;
+		int *count = NULL;
+		double vocab_size = 500, verbose = 1, upright = 1, strength = 1;
+		char ***location = NULL;
+		char **filepath = NULL;
+		char *file = "Bag-Of-Features.yml";
+		int key_size=0, v_key_size=0;
+
+		Mat image;
+		vector<KeyPoint> keypoints;
+		vector<KeyPoint> valid_key;
+		Mat feature_des;
+		Mat dictionary;
+		Mat featuresUnclustered;
+
+		CheckInputArgument(pvApiCtx, 1, 9);						//Check on Number of Input Arguments
+		CheckOutputArgument(pvApiCtx, 1, 1);						//Check on Number of Output Arguments
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    if(!isListType(pvApiCtx, piAddr1))
+    {
+        Scierror(999, "Error: Invalid first argument. List Expected.\n");
+        return 0;
+    }
+
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr1, 1, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr1, 1, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(int iter = 0 ; iter < iRows * iCols ; iter++)
+    {
+      pstData[iter] = (char*)malloc(sizeof(char) * (piLen[iter] + 1));//+ 1 for null termination
+    }
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr1, 1, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+
+    if(!(strcmp(pstData[0],"imageSet")==0))
+    {
+        Scierror(999, "Error: The input argument is not of type imageSet.\n");
+        return 0;
+    }
+
+    // Extracting Description attribute of input argument
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr1, 2, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr1, 2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    description = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(int iter = 0 ; iter < iRows * iCols ; iter++)
+    {
+      description[iter] = (char*)malloc(sizeof(char) * (piLen[iter] + 1));//+ 1 for null termination
+    }
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr1, 2, &iRows, &iCols, piLen, description);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    descriptionCount = iRows;
+
+    // Extracting Count attribute of input argument
+    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr1, 3, &iRows, &iCols, &count);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    location = (char***) malloc(sizeof(char**) * descriptionCount);
+    sciErr = getListItemAddress(pvApiCtx, piAddr1, 4, &piChild);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    for(int iter = 1; iter<=descriptionCount; iter++)
+    {
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, iter, &iRows, &iCols, NULL, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, iter, &iRows, &iCols, piLen, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      location[iter-1] = (char**)malloc(sizeof(char*) * iRows * iCols);
+      for(int colIter = 0 ; colIter < iRows * iCols ; colIter++)
+      {
+        location[iter-1][colIter] = (char*)malloc(sizeof(char) * (piLen[colIter] + 1));//+ 1 for null termination
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, iter, &iRows, &iCols, piLen, location[iter-1]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+    }
+
+		/*sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		if( !isStringType(pvApiCtx, piAddr2))
+		{
+			Scierror(999, "%s: Wrong type of argument for Location. A string is expected.\n", fname);
+			return 0;
+		}
+		sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, NULL, NULL);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+		//second call to retrieve the length of the string
+		sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			free(piLen);
+			return 0;
+		}
+		filepath = (char**)malloc(sizeof(char*) * iRows * iCols);
+		for(int j=0;j< iRows * iCols; j++)
+		{
+			filepath[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));
+		}
+
+		//third call to retrieve data
+		sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, filepath);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			free(piLen);
+			free(filepath);
+			return 0;
+		}*/
+
+    inp_params = *getNbInputArgument(pvApiCtx);
+    for(int i=2; i<=inp_params; i++)
+    {
+      if( inp_params%2 == 0)
+			{
+				Scierror(999,"Either Argument Name or its Value missing\n");
+				return 0;
+			}
+      sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddr3);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+      //Check for Argument type
+			if( !isStringType(pvApiCtx, piAddr3))
+			{
+				Scierror(999, "%s: Wrong type of argument for Name of Optional Argument. A string is expected.\n", fname);
+				return 0;
+			}
+			//Matrix of Stings
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, NULL, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+			//second call to retrieve the length of the string
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(piLen);
+				return 0;
+			}
+			arg = (char**)malloc(sizeof(char*) * iRows * iCols);
+			for(int j=0;j< iRows * iCols; j++)
+			{
+				arg[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));
+			}
+
+			//third call to retrieve data
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen, arg);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(piLen);
+				free(arg);
+				return 0;
+			}
+
+      if(strcmp(arg[0],"VocabularySize") == 0)
+      {
+				if( count_vocab != 0)
+				{
+					Scierror(999,"Voabulary Size has been called twice.\n");
+					return 0;
+				}
+				free(arg);
+				free(piLen);
+        sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr4);
+        if(sciErr.iErr)
+        {
+          printError(&sciErr, 0);
+          return 0;
+        }
+        if( !(isDoubleType(pvApiCtx, piAddr4)||isIntegerType(pvApiCtx, piAddr4)))
+        {
+          Scierror(999,"Not a valid type of value for VocabularySize.\n");
+          return 0;
+        }
+        //Reading the Value of the argument
+        if(getScalarDouble(pvApiCtx, piAddr4, &vocab_size))
+        {
+          Scierror(999,"Not a valid type of value for VocabularySize.\n");
+          return 0;
+        }
+        if(vocab_size < 0)
+        {
+          Scierror(999,"Enter a valid value for Vacabulary Size\n");
+          return 0;
+        }
+				i++;
+        count_vocab += 1;
+      }
+      else if(strcmp(arg[0],"StrongestFeatures") == 0)
+      {
+        if( count_strength != 0)
+				{
+					Scierror(999,"Strength Features has been called twice.\n");
+					return 0;
+				}
+				free(arg);
+				free(piLen);
+        sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr4);
+        if(sciErr.iErr)
+        {
+          printError(&sciErr, 0);
+          return 0;
+        }
+        if( !isDoubleType(pvApiCtx, piAddr4) )
+        {
+          Scierror(999,"Not a valid type of value for StrongestFeatures.\n");
+          return 0;
+        }
+        //Reading the Value of the argument
+        if(getScalarDouble(pvApiCtx, piAddr4, &strength))
+        {
+          Scierror(999,"Not a valid type of value for StrongestFeatures.\n");
+          return 0;
+        }
+        if( strength<0 || strength>=1 )
+        {
+          Scierror(999,"Enter a valid value for Strongest Features (between 0 and 1)\n");
+          return 0;
+        }
+				i++;
+        count_strength += 1;
+      }
+      else if(strcmp(arg[0],"Verbose") == 0)
+      {
+        if( count_ver != 0)
+				{
+					Scierror(999,"Verbose has been called twice.\n");
+					return 0;
+				}
+				free(arg);
+				free(piLen);
+        sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr4);
+        if(sciErr.iErr)
+        {
+          printError(&sciErr, 0);
+          return 0;
+        }
+        if( !(isDoubleType(pvApiCtx, piAddr4)||isIntegerType(pvApiCtx, piAddr4)))
+        {
+          Scierror(999,"Not a valid type of value for Verbose.\n");
+          return 0;
+        }
+        //Reading the Value of the argument
+        if(getScalarDouble(pvApiCtx, piAddr4, &verbose))
+        {
+          Scierror(999,"Not a valid type of value for Verbose.\n");
+          return 0;
+        }
+        if( !(verbose == 1|| verbose == 0) )
+        {
+          Scierror(999,"Enter a valid value for Verbose (Either 0 or 1)\n");
+          return 0;
+        }
+				i++;
+        count_ver += 1;
+      }
+      else if(strcmp(arg[0],"Upright") == 0)
+      {
+        if( count_up != 0)
+				{
+					Scierror(999,"Upright has been called twice.\n");
+					return 0;
+				}
+				free(arg);
+				free(piLen);
+        sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr4);
+        if(sciErr.iErr)
+        {
+          printError(&sciErr, 0);
+          return 0;
+        }
+        if( !(isDoubleType(pvApiCtx, piAddr4)||isIntegerType(pvApiCtx, piAddr4)))
+        {
+          Scierror(999,"Not a valid type of value for Upright.\n");
+          return 0;
+        }
+        //Reading the Value of the argument
+        if(getScalarDouble(pvApiCtx, piAddr4, &upright))
+        {
+          Scierror(999,"Not a valid type of value for Upright.\n");
+          return 0;
+        }
+        if(!(upright == 1 || upright == 0))
+        {
+          Scierror(999,"Enter a valid value for Upright (Either 0 or 1)\n");
+          return 0;
+        }
+				i++;
+        count_up += 1;
+      }
+      else
+      {
+        Scierror(999,"Invalid Argument Name\n");
+        return 0;
+      }
+    }
+
+		filepath = (char**)malloc(sizeof(char*)*1*1);
+		filepath[0] = (char*)malloc(sizeof(char)*20);
+		strcpy(filepath[0],file);
+		/*int flag=1;
+		for(int i=0; location[0][0][i]; i++)
+		{
+			common = location[0][0][i];
+			for(int j=0; j<descriptionCount; j++)
+			{
+				if(location[j][0][i] != common)
+					flag = 0;
+			}
+			if(flag == 0)
+			{
+				common_len = i;
+				break;
+			}
+																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										}
+		strncpy(filepath[0], location[0][0], common_len);
+		strcat(filepath[0], file);
+		*/
+
+		SurfFeatureDetector detector(1, 4, 2, 1, int(upright));
+		Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(1, 4, 2, 1, int(upright));
+		if(int(verbose))
+		{
+			sciprint("Creating Bag-Of-Features from %d image sets.\n\n",descriptionCount);
+			for(int i=0; i<descriptionCount; i++)
+				sciprint("Image set %d: %s\n",i+1,description[i]);
+			sciprint("\nExtracting SURF Features from each image set.\n\n");
+		}
+
+		for( int i=0; i<descriptionCount; i++)
+		{
+			if(int(verbose))
+				sciprint("Extracting features from %d images in image set %d ...",count[i],i+1);
+			key_size = 0;
+			v_key_size = 0;
+			for( int j=0; j<count[i]; j++)
+			{
+				valid_key.clear();
+				keypoints.clear();
+				image = imread(location[i][j],0);
+				detector.detect(image, keypoints);
+				sort(keypoints.begin(), keypoints.end(), response_comparator);
+				for( int k=0; k<(keypoints.size()*strength); k++)
+				{
+					valid_key.push_back(keypoints[k]);
+				}
+				extractor->compute(image, valid_key, feature_des);
+				featuresUnclustered.push_back(feature_des);
+				key_size += keypoints.size();
+				v_key_size += valid_key.size();
+			}
+			if(int(verbose))
+			{
+				sciprint("done. Extracted %d features.\n",key_size);
+				sciprint("Keeping %f percent of the strongest features.\n",(strength)*100);
+				sciprint("Net Extracted features : %d\n\n",v_key_size);
+			}
+		}
+
+		if(vocab_size > featuresUnclustered.rows)
+			vocab_size = featuresUnclustered.rows;
+		TermCriteria tc(CV_TERMCRIT_ITER, 100, 0.001);
+	  int retries = 3;
+		BOWKMeansTrainer bowTrainer(int(vocab_size), tc, retries, KMEANS_PP_CENTERS);
+
+		if(int(verbose))
+		{
+			sciprint("Using K-Means Clustering to create a %d word visual vocabulary.\n",int(vocab_size));
+			sciprint("Number of Features : %d\n",featuresUnclustered.rows);
+			sciprint("Number of Clusters : %d\n\n",int(vocab_size));
+		}
+
+		dictionary = bowTrainer.cluster(featuresUnclustered);
+
+		if(int(verbose))
+			sciprint("Finished creating Bag-Of-Features\n");
+
+		FileStorage fs(filepath[0], FileStorage::WRITE);
+	  fs<<"dictionary"<<dictionary;
+	  fs.release();
+
+    sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 5, &piAddr);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 1, 1, &objectType);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 1, 1, filepath);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 1, 1, &vocab_size);
+    if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 4, 1, 1, &strength);
+    if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 5, 1, 1, &upright);
+    if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		return 0;
+  }
+}