First CommitHEADmaster

135 files changed, 36869 insertions, 0 deletions

diff --git a/sci_gateway1/builder_gateway.sce b/sci_gateway1/builder_gateway.sce
new file mode 100644
index 0000000..2b192bb
--- /dev/null
+++ b/sci_gateway1/builder_gateway.sce
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the BSD.
+// This source file is licensed as described in the file LICENSE, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// https://opensource.org/licenses/BSD-3-Clause
+// Author: Harpreet Singh
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+sci_gateway_dir = get_absolute_file_path('builder_gateway.sce');
+
+tbx_builder_gateway_lang('cpp', sci_gateway_dir);
+tbx_build_gateway_loader(['cpp'], sci_gateway_dir);
+
+clear tbx_builder_gateway_lang tbx_build_gateway_loader;
+clear sci_gateway_dir;
diff --git a/sci_gateway1/cpp/builder_gateway_cpp.sce b/sci_gateway1/cpp/builder_gateway_cpp.sce
new file mode 100644
index 0000000..e450af1
--- /dev/null
+++ b/sci_gateway1/cpp/builder_gateway_cpp.sce
@@ -0,0 +1,312 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the BSD.
+// This source file is licensed as described in the file LICENSE, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// https://opensource.org/licenses/BSD-3-Clause
+// Author: Shamika Mohanan
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+//mode(-1)
+//lines(0)
+
+//toolbox_title = "FOSSEE_Image_Processing_Toolbox";
+
+//Build_64Bits = %t;
+
+//path_builder = get_absolute_file_path('builder_gateway_cpp.sce');
+
+Function_Names = [
+		"opencv_imread","opencv_imread";
+//            //"blur","opencv_blur";
+//            //"arrowedline","opencv_arrowedline";
+//            //"canny","opencv_canny";
+//            //"circle","opencv_circle";
+//            //"clipline","opencv_clipline";
+//            //"convexhull","opencv_convexhull";
+//            //"cornerEigenValsAndVecs","opencv_cornerEigenValsAndVecs";
+//            //"cornerHarris","opencv_cornerHarris";
+//            //"cornerMinEigenVal","opencv_cornerMinEigenVal";
+//            //"dilate","opencv_dilate";
+//            //"ellipse2poly","opencv_ellipse2poly";
+//            //"erode","opencv_erode";
+//            //"fillconvexpoly","opencv_fillconvexpoly";
+//            //"filter2D","opencv_filter2D";
+//            //"findContours","opencv_findContours";
+//            //"gaussianblur","opencv_gaussianblur";
+//            //"getStructuringElement","opencv_getStructuringElement";
+//            //"getTextSize","opencv_getTextSize";
+//            //"goodfeaturestotrack","opencv_goodfeaturestotrack";
+//            //"houghcircles","opencv_houghcircles";
+//            //"houghlines","opencv_houghlines";
+//            //"im2double","opencv_im2double";
+//            //"imcontrast","opencv_imcontrast";
+            "opencv_imcrop","opencv_imcrop";
+            "opencv_imresize","opencv_imresize";
+            "opencv_imsharpen","opencv_imsharpen";
+            "opencv_imwrite","opencv_imwrite";
+//            //"laplacian","opencv_laplacian";
+//            //"line","opencv_line";
+//            //"medianblur","opencv_medianblur";
+//            //"puttext","opencv_puttext";
+//            //"scharr","opencv_scharr";
+//            //"sobel","opencv_sobel";
+//            //"threshold","opencv_threshold";
+//            //"undistort","opencv_undistort";
+//            //"boundingRect","opencv_boundingRect";
+//            //"ellipse","opencv_ellipse";
+//            //"montage","opencv_montage";
+//            //"morphologyEx","opencv_morphologyEx";
+//            //"pyrDown","opencv_pyrDown";
+//            //"pyrUp","opencv_pyrUp";
+//            //"rectangle","opencv_rectangle";
+//            //"sepFilter2D","opencv_sepFilter2D";
+//            //"copymakeborder","opencv_copymakeborder";
+//            //"cvtColor","opencv_cvtColor";
+//            //"getgaussiankernel","opencv_getgaussiankernel";
+//            //"getrectsubpix","opencv_getrectsubpix";
+//            //"getrotationmatrix2D","opencv_getrotationmatrix2D";
+//            //"houghlinesp","opencv_houghlinesp";
+//            //"demosaic", "opencv_demosaic";
+//            //"imfindcircles", "opencv_imfindcircles";
+//            "opencv_detectHarrisFeatures", "opencv_detectHarrisFeatures";
+//            "opencv_detectMinEigenFeatures", "opencv_detectMinEigenFeatures";
+//            "opencv_corner","opencv_corner";
+//            "opencv_ocr","opencv_ocr";
+//            "opencv_imageSet","opencv_imageSet";
+//            "opencv_partition","opencv_partition";
+//	    "opencv_trainImageCategoryClassifier","opencv_trainImageCategoryClassifier";
+//            "opencv_bagOfFeatures","opencv_bagOfFeatures";
+//	    "opencv_predict","opencv_predict";
+//	    "opencv_evaluate","opencv_evaluate";
+//	    "opencv_detectCheckerboardPoints","opencv_detectCheckerboardPoints";
+//	    //"opencv_TemplateMatcher", "opencv_TemplateMatcher";
+//	    //"opencv_peopleDetector", "opencv_peopleDetector";
+//     	    //"opencv_IDCT", "opencv_IDCT";
+//	    //"opencv_isEpipoleInImage", "opencv_isEpipoleInImage";
+//	    //"opencv_undistortImage", "opencv_undistortImage";
+//	    //"opencv_bundleAdjustment", "opencv_bundleAdjustment";
+//	    "opencv_projectPoints","opencv_projectPoints";
+//	    "opencv_estimateFundamentalMatrix","opencv_estimateFundamentalMatrix";
+//	    "opencv_estimateUncalibratedRectification","opencv_estimateUncalibratedRectification";
+//	    "opencv_FFT","opecv_FFT";
+//	    "IFFT","opencv_IFFT";
+//            "GeometricShearer","opencv_GeometricShearer";
+//            "pyramid","opencv_pyramid";
+//            "insertObjectAnnotation","opencv_CascadeObjectDetector";
+//            "rectifyStereoImages","opencv_rectifyStereoImages";
+//            "bbox2points","opencv_bbox2points";
+//            "bboxOverlapRatio","opencv_bboxOverlapRatio";
+//            "BlockMatcher","opencv_BlockMatcher";
+//            "cameraMatrix","opencv_cameraMatrix";
+//            "extractLBPFeatures","opencv_extractLBPFeatures";
+//            "genCheckerboardPoints","opencv_generateCheckerboardPoints";
+//            "HistogramBasedTracker","opencv_HistogramBasedTracker";
+//            "integralFilter","opencv_integralFilter";
+//            "integralImage","opencv_integralImage";
+//            "integralKernel","opencv_integralKernel";
+//            "rotationVectorToMatrix","opencv_rotationVectorToMatrix";
+//            "VideoPlayer","opencv_VideoPlayer";
+//	    "detectFASTFeatures","opencv_detectFASTFeatures";
+//	    "detectMSERFeatures","opencv_detectMSERFeatures";
+//	    "evaluateImageRetieval","opencv_evaluateImageRetrieval";
+//	    "extractFeatures","opencv_extractFeatures";
+//	    "matchFeatures","opencv_matchFeatures";
+//	    "retrieveImages","opencv_retrieveImages";
+//	    "indexImages","opencv_indexImages";
+//	    "ocv_detectSURFFeatures", "opencv_detectSURFFeatures";
+//	    "KalmanFilter","opencv_KalmanFilter";
+//	    "isfilter", "opencv_isfilter";
+//	    "convolver","opencv_convolver";
+//            "opticalFlowFarneback","opencv_opticalFlowFarneback";
+//   	    "extractHOGFeatures","opencv_extractHOGFeatures";
+//	    "showMatchedFeatures","opencv_showMatchedFeatures";
+//	    "estimateGeometricTransform","opencv_estimateGeometricTransform";
+//            "epipolarlines","opencv_epipolarlines";
+//        "ocv_SURFPoints", "opencv_SURFPoints";
+//        "ocv_detectBRISKFeatures", "opencv_detectBRISKFeatures";
+//        "ocv_BRISKPoints", "opencv_BRISKPoints";
+//        "ocv_VideoReader", "opencv_VideoReader";
+//        "ocv_hasFrame", "has_frame";
+//        "ocv_readFrame", "read_frame";
+//        "rotationMatrixToVector", "rotationMTV";
+//        "ocv_ForegroundDetector", "opencv_ForegroundDetector";
+//        "ocv_readForegroundMask", "opencv_readForegroundMask";
+//        "rotationMatrixtoVector", "rotationMTV";
+//            "opencv_blobAnalysis", "opencv_blobAnalysis";
+//            "opencv_DCT", "opencv_DCT"
+//            "opencv_Deinterlacer", "opencv_Deinterlacer";
+//            "opencv_triangulatePoints", "opencv_triangulatePoints";
+//            "opencv_undistortPoints", "opencv_undistortPoints";
+		];
+
+files = [
+//        "common.cpp",
+		"opencv_imread.cpp",
+//            //"opencv_blur.cpp",
+//            //"opencv_arrowedline.cpp",
+//            //"opencv_canny.cpp",
+//            //"opencv_circle.cpp",
+//            //"opencv_clipline.cpp",
+//            //"opencv_convexhull.cpp",
+//            //"opencv_cornerEigenValsAndVecs.cpp"
+//            //"opencv_cornerHarris.cpp",
+//            //"opencv_cornerMinEigenVal.cpp",
+//            //"opencv_dilate.cpp",
+//            //"opencv_ellipse2poly.cpp",
+//            //"opencv_erode.cpp",
+//            //"opencv_fillconvexpoly.cpp",
+//            //"opencv_filter2D.cpp",
+//            //"opencv_findContours.cpp",
+//            //"opencv_gaussianblur.cpp",
+//            //"opencv_getStructuringElement.cpp",
+//            //"opencv_getTextSize.cpp",
+//            //"opencv_goodfeaturestotrack.cpp",
+//            //"opencv_houghcircles.cpp",
+//            //"opencv_houghlines.cpp",
+//            //"opencv_im2double.cpp",
+//            //"opencv_imcontrast.cpp",
+            "opencv_imcrop.cpp",
+            "opencv_imresize.cpp",
+            "opencv_imsharpen.cpp",
+            "opencv_imwrite.cpp",
+//            //"opencv_laplacian.cpp",
+//            //"opencv_line.cpp",
+//            //"opencv_medianblur.cpp",
+//            //"opencv_puttext.cpp",
+//            //"opencv_scharr.cpp",
+//            //"opencv_sobel.cpp",
+//            //"opencv_threshold.cpp",
+//            //"opencv_undistort.cpp",
+//            //"opencv_boundingRect.cpp",
+//            //"opencv_ellipse.cpp",
+//            //"opencv_montage.cpp",
+//            //"opencv_morphologyEx.cpp",
+//            //"opencv_pyrDown.cpp",
+//            //"opencv_pyrUp.cpp",
+//            //"opencv_rectangle.cpp",
+//            //"opencv_sepFilter2D.cpp",
+//            //"opencv_copymakeborder.cpp",
+//            //"opencv_cvtColor.cpp",
+//            //"opencv_getgaussiankernel.cpp",
+//            //"opencv_getrectsubpix.cpp",
+//            //"opencv_getrotationmatrix2D.cpp",
+//            //"opencv_houghlinesp.cpp",
+//            //"opencv_demosaic.cpp",
+//            //"opencv_imfindcircles.cpp",
+//            "opencv_detectHarrisFeatures.cpp",
+//            "opencv_detectMinEigenFeatures.cpp",
+//            "opencv_corner.cpp",
+//            "opencv_ocr.cpp",
+//            "opencv_imageSet.cpp",
+//            "opencv_partition.cpp",
+//		"opencv_trainImageCategoryClassifier.cpp",
+//		"opencv_bagOfFeatures.cpp",
+//		"opencv_predict.cpp",
+//		"opencv_evaluate.cpp",
+//		"opencv_detectCheckerboardPoints.cpp",
+//		//"opencv_TemplateMatcher.cpp",
+//		//"opencv_peopleDetector.cpp",
+//		//"opencv_IDCT.cpp",
+//		//"opencv_isEpipoleInImage.cpp",
+//		//"opencv_undistortImage.cpp",
+//		//"opencv_bundleAdjustment.cpp",
+//		"opencv_projectPoints.cpp",
+//		"opencv_estimateFundamentalMatrix.cpp",
+//		"opencv_estimateUncalibratedRectification.cpp",
+//		"opencv_FFT.cpp"
+//		"opencv_IFFT.cpp",
+//            "opencv_GeometricShearer.cpp",
+//            "opencv_pyramid.cpp",
+//            "opencv_CascadeObjectDetector.cpp",
+//            "opencv_rectifyStereoImages.cpp",
+//            "opencv_bbox2points.cpp",
+//            "opencv_bboxOverlapRatio.cpp",
+//            "opencv_BlockMatcher.cpp",
+//            "opencv_cameraMatrix.cpp",
+//            "opencv_extractLBPFeatures.cpp",
+//            "opencv_generateCheckerboardPoints.cpp",
+//            "opencv_HistogramBasedTracker.cpp",
+//            "opencv_integralFilter.cpp",
+//            "opencv_integralImage.cpp",
+//            "opencv_integralKernel.cpp",
+//            "opencv_rotationVectorToMatrix.cpp",
+//            "opencv_VideoPlayer.cpp",
+//	    "opencv_detectFASTFeatures.cpp",
+//	    "opencv_detectMSERFeatures.cpp",
+//	    "opencv_evaluateImageRetrieval.cpp",
+//	    "opencv_extractFeatures.cpp",
+//	    "opencv_matchFeatures.cpp",
+//	    "opencv_retrieveImages.cpp",
+//	    "opencv_indexImages.cpp",
+//	    "opencv_KalmanFilter.cpp",
+//	    "opencv_isfilter.cpp",
+//	    "opencv_convolver.cpp",
+//            "opencv_opticalFlowFarneback.cpp",
+//	    "opencv_extractHOGFeatures.cpp",
+//	    "opencv_showMatchedFeatures.cpp",
+//	    "opencv_estimateGeometricTransform.cpp",
+//	    "opencv_epipolarlines.cpp",
+//          "opencv_detectSURFFeatures.cpp",
+//            "opencv_SURFPoints.cpp",
+//            "opencv_detectBRISKFeatures.cpp",
+//            "opencv_BRISKPoints.cpp",
+//            "opencv_VideoReader.cpp",
+//            "rotationMatrixToVector.cpp",
+//            "opencv_ForegroundDetector.cpp",
+//            "opencv_blobAnalysis.cpp",
+//            "opencv_DCT.cpp",
+//            "opencv_Deinterlacer.cpp",
+//            "opencv_triangulatePoints.cpp",
+//            "opencv_undistortPoints.cpp"
+		];
+//[a, opt] = getversion();
+//Version = opt(2);
+
+////Build_64Bits = %f;
+
+//if getos()=="Windows" then
+////	third_dir = path_builder+filesep()+'..'+filesep()+'..'+filesep()+'thirdparty';
+////	lib_base_dir = third_dir + filesep() + 'windows' + filesep() + 'lib' + filesep() + Version + filesep();
+////	inc_base_dir = third_dir + filesep() + 'windows' + filesep() + 'include' + filesep() + 'coin';
+////    C_Flags=['-D__USE_DEPRECATED_STACK_FUNCTIONS__ -w -I '+path_builder+' '+ '-I '+inc_base_dir+' ']
+////    Linker_Flag  = [lib_base_dir+"libClp.lib "+lib_base_dir+"libCgl.lib "+lib_base_dir+"libOsi.lib "+lib_base_dir+"libOsiClp.lib "+lib_base_dir+"libCoinUtils.lib "+lib_base_dir+"libSymphony.lib "+lib_base_dir+"IpOptFSS.lib "+lib_base_dir+"IpOpt-vc10.lib "]
+
+//else
+//	third_dir = path_builder+filesep()+'..'+filesep()+'..'+filesep()+'thirdparty';
+//	lib_base_dir = third_dir + filesep() + 'linux' + filesep() + 'lib' + filesep() + Version + filesep();
+//	inc_base_dir = third_dir + filesep() + 'linux' + filesep() + 'include' + filesep() + 'opencv';
+//	incl_base_dir = third_dir + filesep() + 'linux' + filesep() + 'include' + filesep() + 'opencv2';
+//    
+////    C_Flags=[" -I"+inc_base_dir+" "+"- I"+incl_base_dir]
+//    C_Flags=[" -I/usr/include/scilab -I/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/thirdparty/linux/include/opencvopencv -I/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/thirdparty/linux/include/opencvopencv2"]
+//    
+//    
+////    Linker_Flag = ["-L"+lib_base_dir+"libopencv_core"+" "+"-L"+lib_base_dir+"libopencv_highgui"+" "+"-L"+lib_base_dir+"libopencv_imgproc"]
+//    Linker_Flag = ["-L/usr/lib -lopencv_core -L/usr/lib -lopencv_highgui -L/usr/lib -lopencv_imgproc"]
+//    
+//end
+
+//copyfile("sci_gateway/cpp/common.h",TMPDIR);
+//copyfile("sci_gateway/cpp/common.cpp",TMPDIR);
+
+//tbx_build_gateway(toolbox_title,Function_Names,files,get_absolute_file_path("builder_gateway_cpp.sce"), [], Linker_Flag, C_Flags,[]);
+
+//clear toolbox_title Function_Names files Linker_Flag C_Flags;
+
+
+function builder_gw_cpp()
+    WITHOUT_AUTO_PUTLHSVAR = %t;
+    copyfile("/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/sci_gateway/cpp/common.h",TMPDIR);
+    copyfile("/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/sci_gateway/cpp/common.cpp",TMPDIR);
+    tbx_build_gateway("skeleton_imageprocessing", ..
+	Function_Names, ..
+    files, ..
+    get_absolute_file_path("builder_gateway_cpp.sce"),[],["-L/usr/local/lib -lopencv_core -L/usr/local/lib -lopencv_highgui -L/usr/local/lib -lopencv_imgproc -L/usr/local/lib -lopencv_calib3d -L/usr/local/lib -lopencv_video -L/usr/local/lib -lopencv_nonfree -L/usr/local/lib -lopencv_ml -L/usr/local/lib -lopencv_objdetect"],["-I/usr/include/scilab -I/usr/include/opencv -I/usr/include/opencv2 "],"g++ ");
+//    get_absolute_file_path("builder_gateway_cpp.sce"),[],["-L/usr/local/lib -lopencv_core -L/usr/local/lib -lopencv_highgui -L/usr/local/lib -lopencv_imgproc -L/usr/local/lib -lopencv_calib3d -L/usr/local/lib -lopencv_video -L/usr/local/lib -ltesseract -L/usr/local/lib -llept -L/usr/local/lib -lopencv_nonfree -L/usr/local/lib -lopencv_ml -L/usr/local/lib -lopencv_objdetect"],["-I/usr/include/scilab -I/usr/include/opencv -I/usr/include/opencv2 -I/usr/include/tesseract"],"g++ ");
+endfunction
+
+builder_gw_cpp();
+clear builder_gw_cpp; // remove builder_gw_cpp on stack
diff --git a/sci_gateway1/cpp/builder_gateway_cpp.sce~ b/sci_gateway1/cpp/builder_gateway_cpp.sce~
new file mode 100644
index 0000000..f9b2fc3
--- /dev/null
+++ b/sci_gateway1/cpp/builder_gateway_cpp.sce~
@@ -0,0 +1,312 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the BSD.
+// This source file is licensed as described in the file LICENSE, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// https://opensource.org/licenses/BSD-3-Clause
+// Author: Shamika Mohanan
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+//mode(-1)
+//lines(0)
+
+//toolbox_title = "FOSSEE_Image_Processing_Toolbox";
+
+//Build_64Bits = %t;
+
+//path_builder = get_absolute_file_path('builder_gateway_cpp.sce');
+
+Function_Names = [
+		"opencv_imread","opencv_imread";
+//            //"blur","opencv_blur";
+//            //"arrowedline","opencv_arrowedline";
+//            //"canny","opencv_canny";
+//            //"circle","opencv_circle";
+//            //"clipline","opencv_clipline";
+//            //"convexhull","opencv_convexhull";
+//            //"cornerEigenValsAndVecs","opencv_cornerEigenValsAndVecs";
+//            //"cornerHarris","opencv_cornerHarris";
+//            //"cornerMinEigenVal","opencv_cornerMinEigenVal";
+//            //"dilate","opencv_dilate";
+//            //"ellipse2poly","opencv_ellipse2poly";
+//            //"erode","opencv_erode";
+//            //"fillconvexpoly","opencv_fillconvexpoly";
+//            //"filter2D","opencv_filter2D";
+//            //"findContours","opencv_findContours";
+//            //"gaussianblur","opencv_gaussianblur";
+//            //"getStructuringElement","opencv_getStructuringElement";
+//            //"getTextSize","opencv_getTextSize";
+//            //"goodfeaturestotrack","opencv_goodfeaturestotrack";
+//            //"houghcircles","opencv_houghcircles";
+//            //"houghlines","opencv_houghlines";
+//            //"im2double","opencv_im2double";
+//            //"imcontrast","opencv_imcontrast";
+            "imcrop","opencv_imcrop";
+            "imresize","opencv_imresize";
+            "imsharpen","opencv_imsharpen";
+            "imwrite","opencv_imwrite";
+//            //"laplacian","opencv_laplacian";
+//            //"line","opencv_line";
+//            //"medianblur","opencv_medianblur";
+//            //"puttext","opencv_puttext";
+//            //"scharr","opencv_scharr";
+//            //"sobel","opencv_sobel";
+//            //"threshold","opencv_threshold";
+//            //"undistort","opencv_undistort";
+//            //"boundingRect","opencv_boundingRect";
+//            //"ellipse","opencv_ellipse";
+//            //"montage","opencv_montage";
+//            //"morphologyEx","opencv_morphologyEx";
+//            //"pyrDown","opencv_pyrDown";
+//            //"pyrUp","opencv_pyrUp";
+//            //"rectangle","opencv_rectangle";
+//            //"sepFilter2D","opencv_sepFilter2D";
+//            //"copymakeborder","opencv_copymakeborder";
+//            //"cvtColor","opencv_cvtColor";
+//            //"getgaussiankernel","opencv_getgaussiankernel";
+//            //"getrectsubpix","opencv_getrectsubpix";
+//            //"getrotationmatrix2D","opencv_getrotationmatrix2D";
+//            //"houghlinesp","opencv_houghlinesp";
+//            //"demosaic", "opencv_demosaic";
+//            //"imfindcircles", "opencv_imfindcircles";
+//            "opencv_detectHarrisFeatures", "opencv_detectHarrisFeatures";
+//            "opencv_detectMinEigenFeatures", "opencv_detectMinEigenFeatures";
+//            "opencv_corner","opencv_corner";
+//            "opencv_ocr","opencv_ocr";
+//            "opencv_imageSet","opencv_imageSet";
+//            "opencv_partition","opencv_partition";
+//	    "opencv_trainImageCategoryClassifier","opencv_trainImageCategoryClassifier";
+//            "opencv_bagOfFeatures","opencv_bagOfFeatures";
+//	    "opencv_predict","opencv_predict";
+//	    "opencv_evaluate","opencv_evaluate";
+//	    "opencv_detectCheckerboardPoints","opencv_detectCheckerboardPoints";
+//	    //"opencv_TemplateMatcher", "opencv_TemplateMatcher";
+//	    //"opencv_peopleDetector", "opencv_peopleDetector";
+//     	    //"opencv_IDCT", "opencv_IDCT";
+//	    //"opencv_isEpipoleInImage", "opencv_isEpipoleInImage";
+//	    //"opencv_undistortImage", "opencv_undistortImage";
+//	    //"opencv_bundleAdjustment", "opencv_bundleAdjustment";
+//	    "opencv_projectPoints","opencv_projectPoints";
+//	    "opencv_estimateFundamentalMatrix","opencv_estimateFundamentalMatrix";
+//	    "opencv_estimateUncalibratedRectification","opencv_estimateUncalibratedRectification";
+//	    "opencv_FFT","opecv_FFT";
+//	    "IFFT","opencv_IFFT";
+//            "GeometricShearer","opencv_GeometricShearer";
+//            "pyramid","opencv_pyramid";
+//            "insertObjectAnnotation","opencv_CascadeObjectDetector";
+//            "rectifyStereoImages","opencv_rectifyStereoImages";
+//            "bbox2points","opencv_bbox2points";
+//            "bboxOverlapRatio","opencv_bboxOverlapRatio";
+//            "BlockMatcher","opencv_BlockMatcher";
+//            "cameraMatrix","opencv_cameraMatrix";
+//            "extractLBPFeatures","opencv_extractLBPFeatures";
+//            "genCheckerboardPoints","opencv_generateCheckerboardPoints";
+//            "HistogramBasedTracker","opencv_HistogramBasedTracker";
+//            "integralFilter","opencv_integralFilter";
+//            "integralImage","opencv_integralImage";
+//            "integralKernel","opencv_integralKernel";
+//            "rotationVectorToMatrix","opencv_rotationVectorToMatrix";
+//            "VideoPlayer","opencv_VideoPlayer";
+//	    "detectFASTFeatures","opencv_detectFASTFeatures";
+//	    "detectMSERFeatures","opencv_detectMSERFeatures";
+//	    "evaluateImageRetieval","opencv_evaluateImageRetrieval";
+//	    "extractFeatures","opencv_extractFeatures";
+//	    "matchFeatures","opencv_matchFeatures";
+//	    "retrieveImages","opencv_retrieveImages";
+//	    "indexImages","opencv_indexImages";
+//	    "ocv_detectSURFFeatures", "opencv_detectSURFFeatures";
+//	    "KalmanFilter","opencv_KalmanFilter";
+//	    "isfilter", "opencv_isfilter";
+//	    "convolver","opencv_convolver";
+//            "opticalFlowFarneback","opencv_opticalFlowFarneback";
+//   	    "extractHOGFeatures","opencv_extractHOGFeatures";
+//	    "showMatchedFeatures","opencv_showMatchedFeatures";
+//	    "estimateGeometricTransform","opencv_estimateGeometricTransform";
+//            "epipolarlines","opencv_epipolarlines";
+//        "ocv_SURFPoints", "opencv_SURFPoints";
+//        "ocv_detectBRISKFeatures", "opencv_detectBRISKFeatures";
+//        "ocv_BRISKPoints", "opencv_BRISKPoints";
+//        "ocv_VideoReader", "opencv_VideoReader";
+//        "ocv_hasFrame", "has_frame";
+//        "ocv_readFrame", "read_frame";
+//        "rotationMatrixToVector", "rotationMTV";
+//        "ocv_ForegroundDetector", "opencv_ForegroundDetector";
+//        "ocv_readForegroundMask", "opencv_readForegroundMask";
+//        "rotationMatrixtoVector", "rotationMTV";
+//            "opencv_blobAnalysis", "opencv_blobAnalysis";
+//            "opencv_DCT", "opencv_DCT"
+//            "opencv_Deinterlacer", "opencv_Deinterlacer";
+//            "opencv_triangulatePoints", "opencv_triangulatePoints";
+//            "opencv_undistortPoints", "opencv_undistortPoints";
+		];
+
+files = [
+//        "common.cpp",
+		"opencv_imread.cpp",
+//            //"opencv_blur.cpp",
+//            //"opencv_arrowedline.cpp",
+//            //"opencv_canny.cpp",
+//            //"opencv_circle.cpp",
+//            //"opencv_clipline.cpp",
+//            //"opencv_convexhull.cpp",
+//            //"opencv_cornerEigenValsAndVecs.cpp"
+//            //"opencv_cornerHarris.cpp",
+//            //"opencv_cornerMinEigenVal.cpp",
+//            //"opencv_dilate.cpp",
+//            //"opencv_ellipse2poly.cpp",
+//            //"opencv_erode.cpp",
+//            //"opencv_fillconvexpoly.cpp",
+//            //"opencv_filter2D.cpp",
+//            //"opencv_findContours.cpp",
+//            //"opencv_gaussianblur.cpp",
+//            //"opencv_getStructuringElement.cpp",
+//            //"opencv_getTextSize.cpp",
+//            //"opencv_goodfeaturestotrack.cpp",
+//            //"opencv_houghcircles.cpp",
+//            //"opencv_houghlines.cpp",
+//            //"opencv_im2double.cpp",
+//            //"opencv_imcontrast.cpp",
+            "opencv_imcrop.cpp",
+            "opencv_imresize.cpp",
+            "opencv_imsharpen.cpp",
+            "opencv_imwrite.cpp",
+//            //"opencv_laplacian.cpp",
+//            //"opencv_line.cpp",
+//            //"opencv_medianblur.cpp",
+//            //"opencv_puttext.cpp",
+//            //"opencv_scharr.cpp",
+//            //"opencv_sobel.cpp",
+//            //"opencv_threshold.cpp",
+//            //"opencv_undistort.cpp",
+//            //"opencv_boundingRect.cpp",
+//            //"opencv_ellipse.cpp",
+//            //"opencv_montage.cpp",
+//            //"opencv_morphologyEx.cpp",
+//            //"opencv_pyrDown.cpp",
+//            //"opencv_pyrUp.cpp",
+//            //"opencv_rectangle.cpp",
+//            //"opencv_sepFilter2D.cpp",
+//            //"opencv_copymakeborder.cpp",
+//            //"opencv_cvtColor.cpp",
+//            //"opencv_getgaussiankernel.cpp",
+//            //"opencv_getrectsubpix.cpp",
+//            //"opencv_getrotationmatrix2D.cpp",
+//            //"opencv_houghlinesp.cpp",
+//            //"opencv_demosaic.cpp",
+//            //"opencv_imfindcircles.cpp",
+//            "opencv_detectHarrisFeatures.cpp",
+//            "opencv_detectMinEigenFeatures.cpp",
+//            "opencv_corner.cpp",
+//            "opencv_ocr.cpp",
+//            "opencv_imageSet.cpp",
+//            "opencv_partition.cpp",
+//		"opencv_trainImageCategoryClassifier.cpp",
+//		"opencv_bagOfFeatures.cpp",
+//		"opencv_predict.cpp",
+//		"opencv_evaluate.cpp",
+//		"opencv_detectCheckerboardPoints.cpp",
+//		//"opencv_TemplateMatcher.cpp",
+//		//"opencv_peopleDetector.cpp",
+//		//"opencv_IDCT.cpp",
+//		//"opencv_isEpipoleInImage.cpp",
+//		//"opencv_undistortImage.cpp",
+//		//"opencv_bundleAdjustment.cpp",
+//		"opencv_projectPoints.cpp",
+//		"opencv_estimateFundamentalMatrix.cpp",
+//		"opencv_estimateUncalibratedRectification.cpp",
+//		"opencv_FFT.cpp"
+//		"opencv_IFFT.cpp",
+//            "opencv_GeometricShearer.cpp",
+//            "opencv_pyramid.cpp",
+//            "opencv_CascadeObjectDetector.cpp",
+//            "opencv_rectifyStereoImages.cpp",
+//            "opencv_bbox2points.cpp",
+//            "opencv_bboxOverlapRatio.cpp",
+//            "opencv_BlockMatcher.cpp",
+//            "opencv_cameraMatrix.cpp",
+//            "opencv_extractLBPFeatures.cpp",
+//            "opencv_generateCheckerboardPoints.cpp",
+//            "opencv_HistogramBasedTracker.cpp",
+//            "opencv_integralFilter.cpp",
+//            "opencv_integralImage.cpp",
+//            "opencv_integralKernel.cpp",
+//            "opencv_rotationVectorToMatrix.cpp",
+//            "opencv_VideoPlayer.cpp",
+//	    "opencv_detectFASTFeatures.cpp",
+//	    "opencv_detectMSERFeatures.cpp",
+//	    "opencv_evaluateImageRetrieval.cpp",
+//	    "opencv_extractFeatures.cpp",
+//	    "opencv_matchFeatures.cpp",
+//	    "opencv_retrieveImages.cpp",
+//	    "opencv_indexImages.cpp",
+//	    "opencv_KalmanFilter.cpp",
+//	    "opencv_isfilter.cpp",
+//	    "opencv_convolver.cpp",
+//            "opencv_opticalFlowFarneback.cpp",
+//	    "opencv_extractHOGFeatures.cpp",
+//	    "opencv_showMatchedFeatures.cpp",
+//	    "opencv_estimateGeometricTransform.cpp",
+//	    "opencv_epipolarlines.cpp",
+//          "opencv_detectSURFFeatures.cpp",
+//            "opencv_SURFPoints.cpp",
+//            "opencv_detectBRISKFeatures.cpp",
+//            "opencv_BRISKPoints.cpp",
+//            "opencv_VideoReader.cpp",
+//            "rotationMatrixToVector.cpp",
+//            "opencv_ForegroundDetector.cpp",
+//            "opencv_blobAnalysis.cpp",
+//            "opencv_DCT.cpp",
+//            "opencv_Deinterlacer.cpp",
+//            "opencv_triangulatePoints.cpp",
+//            "opencv_undistortPoints.cpp"
+		];
+//[a, opt] = getversion();
+//Version = opt(2);
+
+////Build_64Bits = %f;
+
+//if getos()=="Windows" then
+////	third_dir = path_builder+filesep()+'..'+filesep()+'..'+filesep()+'thirdparty';
+////	lib_base_dir = third_dir + filesep() + 'windows' + filesep() + 'lib' + filesep() + Version + filesep();
+////	inc_base_dir = third_dir + filesep() + 'windows' + filesep() + 'include' + filesep() + 'coin';
+////    C_Flags=['-D__USE_DEPRECATED_STACK_FUNCTIONS__ -w -I '+path_builder+' '+ '-I '+inc_base_dir+' ']
+////    Linker_Flag  = [lib_base_dir+"libClp.lib "+lib_base_dir+"libCgl.lib "+lib_base_dir+"libOsi.lib "+lib_base_dir+"libOsiClp.lib "+lib_base_dir+"libCoinUtils.lib "+lib_base_dir+"libSymphony.lib "+lib_base_dir+"IpOptFSS.lib "+lib_base_dir+"IpOpt-vc10.lib "]
+
+//else
+//	third_dir = path_builder+filesep()+'..'+filesep()+'..'+filesep()+'thirdparty';
+//	lib_base_dir = third_dir + filesep() + 'linux' + filesep() + 'lib' + filesep() + Version + filesep();
+//	inc_base_dir = third_dir + filesep() + 'linux' + filesep() + 'include' + filesep() + 'opencv';
+//	incl_base_dir = third_dir + filesep() + 'linux' + filesep() + 'include' + filesep() + 'opencv2';
+//    
+////    C_Flags=[" -I"+inc_base_dir+" "+"- I"+incl_base_dir]
+//    C_Flags=[" -I/usr/include/scilab -I/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/thirdparty/linux/include/opencvopencv -I/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/thirdparty/linux/include/opencvopencv2"]
+//    
+//    
+////    Linker_Flag = ["-L"+lib_base_dir+"libopencv_core"+" "+"-L"+lib_base_dir+"libopencv_highgui"+" "+"-L"+lib_base_dir+"libopencv_imgproc"]
+//    Linker_Flag = ["-L/usr/lib -lopencv_core -L/usr/lib -lopencv_highgui -L/usr/lib -lopencv_imgproc"]
+//    
+//end
+
+//copyfile("sci_gateway/cpp/common.h",TMPDIR);
+//copyfile("sci_gateway/cpp/common.cpp",TMPDIR);
+
+//tbx_build_gateway(toolbox_title,Function_Names,files,get_absolute_file_path("builder_gateway_cpp.sce"), [], Linker_Flag, C_Flags,[]);
+
+//clear toolbox_title Function_Names files Linker_Flag C_Flags;
+
+
+function builder_gw_cpp()
+    WITHOUT_AUTO_PUTLHSVAR = %t;
+    copyfile("/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/sci_gateway/cpp/common.h",TMPDIR);
+    copyfile("/home/fossee/Desktop/FOSSEE_Image_Processing_Toolbox/sci_gateway/cpp/common.cpp",TMPDIR);
+    tbx_build_gateway("skeleton_imageprocessing", ..
+	Function_Names, ..
+    files, ..
+    get_absolute_file_path("builder_gateway_cpp.sce"),[],["-L/usr/local/lib -lopencv_core -L/usr/local/lib -lopencv_highgui -L/usr/local/lib -lopencv_imgproc -L/usr/local/lib -lopencv_calib3d -L/usr/local/lib -lopencv_video -L/usr/local/lib -lopencv_nonfree -L/usr/local/lib -lopencv_ml -L/usr/local/lib -lopencv_objdetect"],["-I/usr/include/scilab -I/usr/include/opencv -I/usr/include/opencv2 "],"g++ ");
+//    get_absolute_file_path("builder_gateway_cpp.sce"),[],["-L/usr/local/lib -lopencv_core -L/usr/local/lib -lopencv_highgui -L/usr/local/lib -lopencv_imgproc -L/usr/local/lib -lopencv_calib3d -L/usr/local/lib -lopencv_video -L/usr/local/lib -ltesseract -L/usr/local/lib -llept -L/usr/local/lib -lopencv_nonfree -L/usr/local/lib -lopencv_ml -L/usr/local/lib -lopencv_objdetect"],["-I/usr/include/scilab -I/usr/include/opencv -I/usr/include/opencv2 -I/usr/include/tesseract"],"g++ ");
+endfunction
+
+builder_gw_cpp();
+clear builder_gw_cpp; // remove builder_gw_cpp on stack
diff --git a/sci_gateway1/cpp/cleaner.sce b/sci_gateway1/cpp/cleaner.sce
new file mode 100644
index 0000000..12b9fbb
--- /dev/null
+++ b/sci_gateway1/cpp/cleaner.sce
@@ -0,0 +1,22 @@
+// This file is released under the 3-clause BSD license. See COPYING-BSD.
+// Generated by builder.sce : Please, do not edit this file
+// cleaner.sce
+// ------------------------------------------------------
+curdir = pwd();
+cleaner_path = get_file_path('cleaner.sce');
+chdir(cleaner_path);
+// ------------------------------------------------------
+if fileinfo('loader.sce') <> [] then
+  mdelete('loader.sce');
+end
+// ------------------------------------------------------
+if fileinfo('libskeleton_imageprocessing.so') <> [] then
+  mdelete('libskeleton_imageprocessing.so');
+end
+// ------------------------------------------------------
+if fileinfo('libskeleton_imageprocessing.c') <> [] then
+  mdelete('libskeleton_imageprocessing.c');
+end
+// ------------------------------------------------------
+chdir(curdir);
+// ------------------------------------------------------
diff --git a/sci_gateway1/cpp/common.cpp b/sci_gateway1/cpp/common.cpp
new file mode 100644
index 0000000..c19f58a
--- /dev/null
+++ b/sci_gateway1/cpp/common.cpp
@@ -0,0 +1,890 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+//takes the matrix type as parameter and returns a string of the type
+string type2str(int type) 
+{
+    string r;
+    uchar depth = type & CV_MAT_DEPTH_MASK;
+    switch ( depth )
+    {
+        case CV_8U:  r = "8U"; break;
+        case CV_8S:  r = "8S"; break;
+        case CV_16U: r = "16U"; break;
+        case CV_16S: r = "16S"; break;
+        case CV_32S: r = "32S"; break;
+        case CV_32F: r = "32F"; break;
+        case CV_64F: r = "64F"; break;
+        default:     r = "User"; break;
+    }
+    return r;
+}
+
+//takes matrix type as parameter and returns no. of channels of the image matrix
+int no_of_channels(int type)
+{
+    uchar chans = 1 + (type >> CV_CN_SHIFT);
+    return chans;
+}
+
+//function used to retrieve image matrix from Scilab environment
+/*
+    We need to retrieve image from the Scilab environment
+    We do this by getting a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int retrieveImage(Mat &image,int pos)
+{
+
+    SciErr sciErr;
+    int iRows=0,iCols=0,i,j,k=0;
+    int *piAddr = NULL;
+    int *piAddrChild = NULL;
+    int iPrec = 0,iItem = 0;
+
+    //retrieving number of items in the list and type of data(integer/float)
+    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piAddrChild);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(isIntegerType(pvApiCtx, piAddrChild))
+    {
+        //getting precision
+        sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrChild, &iPrec);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        switch(iPrec)
+        {
+            case SCI_UINT8: //for unsigned integer 8
+            {
+                if(iItem==3)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    unsigned char *pstDataB = NULL; 
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC3);
+
+                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    unsigned char *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC1);
+
+                    //Assigning matrix value to pixel
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_UINT16: //for unsigned integer 16
+            {
+                if(iItem==3)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    short unsigned int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                     //i+iRows*j
+                        }
+                    }
+                }
+                else
+                {
+                    short unsigned int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC1);
+
+                    //Assigning matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_INT16: //for signed integer 16
+            {
+                if(iItem==3)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    short int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    short int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC1);
+
+                    //Assigning image matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<short>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+        }
+    }
+    else //for floating point/ double precision values
+    {
+        if(iItem==3)
+        {
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            double *pstDataB = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddrChild);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }               
+            //retrive the matrix of the G values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddrChild);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }   
+            //retrive the matrix of the B values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC3);
+
+            //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    image.at<Vec3d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec3d>(i,j)[1]=pstDataG[i+iRows*j];
+                    image.at<Vec3d>(i,j)[0]=pstDataB[i+iRows*j];
+                }
+            }
+        }
+        else
+        {
+            double *pstDataR = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC1);
+
+            //Assigning image matrix values to pixels
+            k=0;
+            for(i=0;i<iRows;i++)
+                for(j=0;j<iCols;j++)
+                    image.at<double>(i,j)=pstDataR[i+iRows*j];
+        }
+    }
+    return 1;
+}
+
+//function that returns an image matrix to the Scilab environment
+/*
+    What we now need, is to pass the image matrix to the Scilab environment.
+    We do this by passing a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int returnImage(char *checker,Mat img,int pos)
+{
+    int i,j,k=0;
+    int *piAddrNew  = NULL;
+    SciErr sciErr;
+    int num=no_of_channels(img.type()); //num now contains no. of channels of the image
+    //creating the list that will be passed to the Scilab enviroment
+    if(num==3)
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 3, &piAddrNew);
+    else
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 1, &piAddrNew);
+    if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);           
+       return 0;
+    }
+    if(strcmp(checker,"8U")==0) //for Unsigned Integer 8
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *b = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3b intensity = img.at<Vec3b>(i, j);
+                    r [i+img.rows*j]=intensity.val[2];
+                    g [i+img.rows*j]=intensity.val[1];
+                    b [i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<uchar>(i, j);
+
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"16U")==0) //for Unsigned Integer 16
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *b = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<ushort>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+    }
+    else if(strcmp(checker,"16S")==0) //for Signed Integer 16
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *b = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<short>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"32S")==0) //for Signed Integer 16
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *b = (int *)malloc(img.rows * img.cols * sizeof(int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3i intensity = img.at<Vec3i>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<int>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+
+    else if(strcmp(checker,"32F")==0) //for Float 32
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<float>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    else if(strcmp(checker,"64F")==0) //For Float 64
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<double>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    
+}
diff --git a/sci_gateway1/cpp/common.cpp~ b/sci_gateway1/cpp/common.cpp~
new file mode 100644
index 0000000..82d542f
--- /dev/null
+++ b/sci_gateway1/cpp/common.cpp~
@@ -0,0 +1,924 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+//takes the matrix type as parameter and returns a string of the type
+string type2str(int type) 
+{
+    string r;
+    uchar depth = type & CV_MAT_DEPTH_MASK;
+    switch ( depth )
+    {
+        case CV_8U:  r = "8U"; break;
+        case CV_8S:  r = "8S"; break;
+        case CV_16U: r = "16U"; break;
+        case CV_16S: r = "16S"; break;
+        case CV_32S: r = "32S"; break;
+        case CV_32F: r = "32F"; break;
+        case CV_64F: r = "64F"; break;
+        default:     r = "User"; break;
+    }
+    return r;
+}
+
+//takes matrix type as parameter and returns no. of channels of the image matrix
+int no_of_channels(int type)
+{
+    uchar chans = 1 + (type >> CV_CN_SHIFT);
+    return chans;
+}
+
+//function used to retrieve image matrix from Scilab environment
+/*
+    We need to retrieve image from the Scilab environment
+    We do this by getting a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int retrieveImage(Mat &image,int pos)
+{
+
+    SciErr sciErr;
+    int iRows=0,iCols=0,i,j,k=0;
+    int *piAddr = NULL;
+    int *piAddr1 = NULL;
+    int *piAddrChild = NULL;
+    int iPrec = 0,iItem = 0;
+    int r=0,c=0;
+
+    //retrieving number of items in the list and type of data(integer/float)
+    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+    
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piAddrChild);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+    
+    
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    if(isIntegerType(pvApiCtx, piAddrChild))
+    {
+        //getting precision
+        sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrChild, &iPrec);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        switch(iPrec)
+        {
+            case SCI_UINT8: //for unsigned integer 8
+            {
+                
+                if(iItem==3)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    unsigned char *pstDataB = NULL; 
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    for(r=0;r<iRows;r++)
+                                    {
+                                        for (c=0;c<iCols;c++)
+                                        {                                
+                                            sciprint("m=%d\n",pstDataR[r+iRows*c]);
+                                        }                            
+                                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    
+                                                 
+                                
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC3);
+
+                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    unsigned char *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC1);
+
+                    //Assigning matrix value to pixel
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_UINT16: //for unsigned integer 16
+            {
+                
+                if(iItem==3)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    short unsigned int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                     //i+iRows*j
+                        }
+                    }
+                }
+                else
+                {
+                    short unsigned int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC1);
+
+                    //Assigning matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_INT16: //for signed integer 16
+            {
+                
+                if(iItem==3)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    short int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    short int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC1);
+
+                    //Assigning image matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<short>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+        }
+    }
+    else //for floating point/ double precision values
+    {
+        
+        if(iItem==3)
+        {
+            
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            double *pstDataB = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }               
+            
+            //retrive the matrix of the G values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }   
+            
+            //retrive the matrix of the B values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC3);
+
+            //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    image.at<Vec3d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec3d>(i,j)[1]=pstDataG[i+iRows*j];
+                    image.at<Vec3d>(i,j)[0]=pstDataB[i+iRows*j];
+                }
+            }
+            
+        }
+        else
+        {
+            
+            double *pstDataR = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr1);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr1, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC1);
+
+            //Assigning image matrix values to pixels
+            k=0;
+            for(i=0;i<iRows;i++)
+                for(j=0;j<iCols;j++)
+                    image.at<double>(i,j)=pstDataR[i+iRows*j];
+        }
+    }
+    return 1;
+}
+
+//function that returns an image matrix to the Scilab environment
+/*
+    What we now need, is to pass the image matrix to the Scilab environment.
+    We do this by passing a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int returnImage(char *checker,Mat img,int pos)
+{
+    int i,j,k=0;
+    int *piAddrNew  = NULL;
+    SciErr sciErr;
+    int num=no_of_channels(img.type()); //num now contains no. of channels of the image
+    //creating the list that will be passed to the Scilab enviroment
+    if(num==3)
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 3, &piAddrNew);
+    else
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 1, &piAddrNew);
+    if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);           
+       return 0;
+    }
+    if(strcmp(checker,"8U")==0) //for Unsigned Integer 8
+    {
+        if(num==3)
+        {
+            
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *b = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3b intensity = img.at<Vec3b>(i, j);
+                    *(r + j*img.rows + i)=intensity.val[2];
+                    *(g + j*img.rows + i)=intensity.val[1];
+                    *(b + j*img.rows + i)=intensity.val[0];
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<uchar>(i, j);
+
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"16U")==0) //for Unsigned Integer 16
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *b = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<ushort>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+    }
+    else if(strcmp(checker,"16S")==0) //for Signed Integer 16
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *b = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<short>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"32S")==0) //for Signed Integer 16
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *b = (int *)malloc(img.rows * img.cols * sizeof(int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3i intensity = img.at<Vec3i>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<int>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+
+    else if(strcmp(checker,"32F")==0) //for Float 32
+    {
+        if(num==3)
+        {
+            
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<float>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    else if(strcmp(checker,"64F")==0) //For Float 64
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<double>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    
+}
diff --git a/sci_gateway1/cpp/common.h b/sci_gateway1/cpp/common.h
new file mode 100644
index 0000000..5de6cf7
--- /dev/null
+++ b/sci_gateway1/cpp/common.h
@@ -0,0 +1,9 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+string type2str(int type);
+int no_of_channels(int type);
+int retrieveImage(Mat &image,int pos);
+int returnImage(char *checker,Mat img,int pos);
+
diff --git a/sci_gateway1/cpp/common.h~ b/sci_gateway1/cpp/common.h~
new file mode 100644
index 0000000..d42d9c7
--- /dev/null
+++ b/sci_gateway1/cpp/common.h~
@@ -0,0 +1,10 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+//using namespace std;
+
+string type2str(int type);
+int no_of_channels(int type);
+int retrieveImage(Mat &image,int pos);
+int returnImage(char *checker,Mat img,int pos);
+//int retrieveImageFromAddress(Mat &image,int *piAddr);
diff --git a/sci_gateway1/cpp/common1.cpp b/sci_gateway1/cpp/common1.cpp
new file mode 100644
index 0000000..41752e6
--- /dev/null
+++ b/sci_gateway1/cpp/common1.cpp
@@ -0,0 +1,897 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+//takes the matrix type as parameter and returns a string of the type
+string type2str(int type) 
+{
+    string r;
+    uchar depth = type & CV_MAT_DEPTH_MASK;
+    switch ( depth )
+    {
+        case CV_8U:  r = "8U"; break;
+        case CV_8S:  r = "8S"; break;
+        case CV_16U: r = "16U"; break;
+        case CV_16S: r = "16S"; break;
+        case CV_32S: r = "32S"; break;
+        case CV_32F: r = "32F"; break;
+        case CV_64F: r = "64F"; break;
+        default:     r = "User"; break;
+    }
+    return r;
+}
+
+//takes matrix type as parameter and returns no. of channels of the image matrix
+int no_of_channels(int type)
+{
+    uchar chans = 1 + (type >> CV_CN_SHIFT);
+    return chans;
+}
+
+//function used to retrieve image matrix from Scilab environment
+/*
+    We need to retrieve image from the Scilab environment
+    We do this by getting a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int retrieveImage(Mat &image,int pos)
+{
+
+    SciErr sciErr;
+    int iRows=0,iCols=0,i,j,k=0;
+    int *piAddr = NULL;
+    int *piAddrChild = NULL;
+    int iPrec = 0,iItem = 0;
+
+    //retrieving number of items in the list and type of data(integer/float)
+    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciprint("Test1");
+    sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piAddrChild);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciprint("Testing1");
+    if(isIntegerType(pvApiCtx, piAddrChild))
+    {
+        //getting precision
+        sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrChild, &iPrec);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        switch(iPrec)
+        {
+            case SCI_UINT8: //for unsigned integer 8
+            {
+                if(iItem==3)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    unsigned char *pstDataB = NULL; 
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC3);
+
+                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    unsigned char *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC1);
+
+                    //Assigning matrix value to pixel
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_UINT16: //for unsigned integer 16
+            {
+                if(iItem==3)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    short unsigned int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                     //i+iRows*j
+                        }
+                    }
+                }
+                else
+                {
+                    short unsigned int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC1);
+
+                    //Assigning matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_INT16: //for signed integer 16
+            {
+                if(iItem==3)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    short int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    short int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC1);
+
+                    //Assigning image matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<short>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+        }
+    }
+    else //for floating point/ double precision values
+    {
+        sciprint("Test2");
+        if(iItem==3)
+        {
+            sciprint("Again");
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            double *pstDataB = NULL;
+//            sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+//            if(sciErr.iErr)   
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }
+            sciprint("Testing2");
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+//            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+//            if(sciErr.iErr)   
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }               
+            sciprint("Testing3");
+            //retrive the matrix of the G values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+//            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+//            if(sciErr.iErr)   
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }   
+            sciprint("Testing4");
+            //retrive the matrix of the B values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC3);
+
+            //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    image.at<Vec3d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec3d>(i,j)[1]=pstDataG[i+iRows*j];
+                    image.at<Vec3d>(i,j)[0]=pstDataB[i+iRows*j];
+                }
+            }
+            sciprint("Test3");
+        }
+        else
+        {
+            double *pstDataR = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC1);
+
+            //Assigning image matrix values to pixels
+            k=0;
+            for(i=0;i<iRows;i++)
+                for(j=0;j<iCols;j++)
+                    image.at<double>(i,j)=pstDataR[i+iRows*j];
+        }
+    }
+    return 1;
+}
+
+//function that returns an image matrix to the Scilab environment
+/*
+    What we now need, is to pass the image matrix to the Scilab environment.
+    We do this by passing a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int returnImage(char *checker,Mat img,int pos)
+{
+    int i,j,k=0;
+    int *piAddrNew  = NULL;
+    SciErr sciErr;
+    int num=no_of_channels(img.type()); //num now contains no. of channels of the image
+    //creating the list that will be passed to the Scilab enviroment
+    if(num==3)
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 3, &piAddrNew);
+    else
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 1, &piAddrNew);
+    if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);           
+       return 0;
+    }
+    if(strcmp(checker,"8U")==0) //for Unsigned Integer 8
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *b = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3b intensity = img.at<Vec3b>(i, j);
+                    *(r + j*img.rows + i)=intensity.val[2];
+                    *(g + j*img.rows + i)=intensity.val[1];
+                    *(b + j*img.rows + i)=intensity.val[0];
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<uchar>(i, j);
+
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"16U")==0) //for Unsigned Integer 16
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *b = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<ushort>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+    }
+    else if(strcmp(checker,"16S")==0) //for Signed Integer 16
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *b = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<short>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"32S")==0) //for Signed Integer 16
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *b = (int *)malloc(img.rows * img.cols * sizeof(int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3i intensity = img.at<Vec3i>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<int>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+
+    else if(strcmp(checker,"32F")==0) //for Float 32
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<float>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    else if(strcmp(checker,"64F")==0) //For Float 64
+    {
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<double>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    
+}
diff --git a/sci_gateway1/cpp/common2.cpp b/sci_gateway1/cpp/common2.cpp
new file mode 100644
index 0000000..0f296ed
--- /dev/null
+++ b/sci_gateway1/cpp/common2.cpp
@@ -0,0 +1,2527 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+//takes the matrix type as parameter and returns a string of the type
+string type2str(int type)
+{
+    string r;
+    uchar depth = type & CV_MAT_DEPTH_MASK;
+    switch ( depth )
+    {
+        case CV_8U:  r = "8U"; break;
+        case CV_8S:  r = "8S"; break;
+        case CV_16U: r = "16U"; break;
+        case CV_16S: r = "16S"; break;
+        case CV_32S: r = "32S"; break;
+        case CV_32F: r = "32F"; break;
+        case CV_64F: r = "64F"; break;
+        default:     r = "User"; break;
+    }
+    return r;
+}
+
+//takes matrix type as parameter and returns no. of channels of the image matrix
+//int no_of_channels(int type)
+//{
+//    uchar chans = 1 + (type >> CV_CN_SHIFT);
+//    return chans;
+//}
+//function used to retrieve image matrix from Scilab environment
+//int retrieveImageFromAddress(Mat &image,int *piAddr)
+//{
+//    SciErr sciErr;
+//    int iRows=0,iCols=0,i,j,k=0;
+//    int *piChild = NULL;
+//    int iPrec = 0,iItem = 0;
+//    sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piChild);
+//    if(sciErr.iErr)
+//    {
+//        printError(&sciErr, 0);
+//        return 0;
+//    }
+//    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+//    if(sciErr.iErr)
+//    {
+//        printError(&sciErr, 0);
+//        return 0;
+//    }
+
+//    if(isIntegerType(pvApiCtx, piChild))
+//    {
+//        //getting precision
+//        sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piChild, &iPrec);
+//        if(sciErr.iErr)
+//        {
+//            printError(&sciErr, 0);
+//            return 0;
+//        }
+//        switch(iPrec)
+//        {
+//            case SCI_UINT8: //for unsigned integer 8
+//            {
+//                if(iItem==3)
+//                {
+//                    unsigned char *pstDataR = NULL;
+//                    unsigned char *pstDataG = NULL;
+//                    unsigned char *pstDataB = NULL;
+//                    //retrive the matrix of the R values
+//                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+//                    //retrive the matrix of the G values
+//                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+//                    //retrive the matrix of the B values
+//                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+
+//                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//                    image = Mat(iRows,iCols,CV_8UC3);
+
+//                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+//                    k=0;
+//                    for(i=0;i<iRows;i++)
+//                    {
+//                        for(j=0;j<iCols;j++)
+//                        {
+//                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+//                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+//                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+//                        }
+//                    }
+//                }
+//                else
+//                {
+//                    unsigned char *pstDataR = NULL;
+//                    //retrive the matrix of the R values
+//                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+
+//                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//                    image = Mat(iRows,iCols,CV_8UC1);
+
+//                    //Assigning matrix value to pixel
+//                    k=0;
+//                    for(i=0;i<iRows;i++)
+//                        for(j=0;j<iCols;j++)
+//                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+//                }
+//                break;
+//            }
+//            case SCI_UINT16: //for unsigned integer 16
+//            {
+//                if(iItem==3)
+//                {
+//                    short unsigned int *pstDataR = NULL;
+//                    short unsigned int *pstDataG = NULL;
+//                    short unsigned int *pstDataB = NULL;
+//                    //retrive the matrix of the R values
+//                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+//                    //retrive the matrix of the G values
+//                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+//                    //retrive the matrix of the B values
+//                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+
+//                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//                    image = Mat(iRows,iCols,CV_16UC3);
+
+//                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+//                    k=0;
+//                    for(i=0;i<iRows;i++)
+//                    {
+//                        for(j=0;j<iCols;j++)
+//                        {
+//                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+//                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+//                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+//                     //i+iRows*j
+//                        }
+//                    }
+//                }
+//                else
+//                {
+//                    short unsigned int *pstDataR = NULL;
+//                    //retrive the matrix of the R values
+//                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+
+//                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//                    image = Mat(iRows,iCols,CV_16UC1);
+
+//                    //Assigning matrix values to pixels
+//                    k=0;
+//                    for(i=0;i<iRows;i++)
+//                        for(j=0;j<iCols;j++)
+//                          image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+//                }
+//                break;
+//            }
+//            case SCI_INT16: //for signed integer 16
+//            {
+//                if(iItem==3)
+//                {
+//                    short int *pstDataR = NULL;
+//                    short int *pstDataG = NULL;
+//                    short int *pstDataB = NULL;
+//                    //retrive the matrix of the R values
+//                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+//                    //retrive the matrix of the G values
+//                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+//                    //retrive the matrix of the B values
+//                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+
+//                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//                    image = Mat(iRows,iCols,CV_16SC3);
+
+//                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+//                    k=0;
+//                    for(i=0;i<iRows;i++)
+//                    {
+//                        for(j=0;j<iCols;j++)
+//                        {
+//                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+//                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+//                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+//                        }
+//                    }
+//                }
+//                else
+//                {
+//                    short int *pstDataR = NULL;
+//                    //retrive the matrix of the R values
+//                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//                    if(sciErr.iErr)
+//                    {
+//                        printError(&sciErr, 0);
+//                        return 0;
+//                    }
+
+//                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//                    image = Mat(iRows,iCols,CV_16SC1);
+
+//                    //Assigning image matrix values to pixels
+//                    k=0;
+//                    for(i=0;i<iRows;i++)
+//                        for(j=0;j<iCols;j++)
+//                          image.at<short>(i,j)=pstDataR[i+iRows*j];
+//                }
+//                break;
+//            }
+//        }
+//    }
+//    else //for floating point/ double precision values
+//    {
+//        if(iItem==3)
+//        {
+//            double *pstDataR = NULL;
+//            double *pstDataG = NULL;
+//            double *pstDataB = NULL;
+//            //retrive the matrix of the R values
+//            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//            if(sciErr.iErr)
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }
+//            //retrive the matrix of the G values
+//            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+//            if(sciErr.iErr)
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }
+//            //retrive the matrix of the B values
+//            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+//            if(sciErr.iErr)
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }
+
+//            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//            image = Mat(iRows,iCols,CV_64FC3);
+
+//            //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+//            k=0;
+//            for(i=0;i<iRows;i++)
+//            {
+//                for(j=0;j<iCols;j++)
+//                {
+//                    image.at<Vec3d>(i,j)[2]=pstDataR[i+iRows*j];
+//                    image.at<Vec3d>(i,j)[1]=pstDataG[i+iRows*j];
+//                    image.at<Vec3d>(i,j)[0]=pstDataB[i+iRows*j];
+//                }
+//            }
+//        }
+//        else
+//        {
+//            double *pstDataR = NULL;
+//            //retrive the matrix of the R values
+//            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+//            if(sciErr.iErr)
+//            {
+//                printError(&sciErr, 0);
+//                return 0;
+//            }
+
+//            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+//            image = Mat(iRows,iCols,CV_64FC1);
+
+//            //Assigning image matrix values to pixels
+//            k=0;
+//            for(i=0;i<iRows;i++)
+//                for(j=0;j<iCols;j++)
+//                    image.at<double>(i,j)=pstDataR[i+iRows*j];
+//        }
+//    }
+//    return 1;
+//}
+//function used to retrieve image matrix from Scilab environment
+/*
+    We need to retrieve image from the Scilab environment
+    We do this by getting a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int retrieveImage(Mat &image,int pos)
+{
+
+    SciErr sciErr;
+    int iRows=0,iCols=0,i,j,k=0;
+    int *piAddr = NULL;
+    int *piAddrChild = NULL;
+    int iPrec = 0,iItem = 0;
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piAddrChild);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(isIntegerType(pvApiCtx, piAddrChild))
+    {
+        //getting precision
+        sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrChild, &iPrec);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        switch(iPrec)
+        {
+            case SCI_UINT8: //for unsigned integer 8
+            {
+                if(iItem==2)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC2);
+
+                    /*Now that we have the 2 matrices(R,G), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec2b>(i,j)[1]=pstDataR[i+iRows*j];
+                          image.at<Vec2b>(i,j)[0]=pstDataG[i+iRows*j];                          
+                        }
+                    }
+                }
+                else if(iItem==3)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    unsigned char *pstDataB = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC3);
+
+                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else if(iItem==4)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    unsigned char *pstDataB = NULL;
+                    unsigned char *pstDataA = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the A values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 4, &iRows, &iCols, &pstDataA);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC4);
+
+                    /*Now that we have the 4 matrices(R,G,B,A), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec4b>(i,j)[3]=pstDataA[i+iRows*j];
+                          image.at<Vec4b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec4b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec4b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    unsigned char *pstDataR = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC1);
+
+                    //Assigning matrix value to pixel
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_INT8: //for signed integer 8
+            {
+                if(iItem==2)
+                {
+                    char *pstDataR = NULL;
+                    char *pstDataG = NULL;
+                    
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8SC2);
+
+                    /*Now that we have the 2 matrices(R,G), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec2b>(i,j)[1]=pstDataR[i+iRows*j];
+                          image.at<Vec2b>(i,j)[0]=pstDataG[i+iRows*j];                          
+                        }
+                    }
+                }
+                else if(iItem==3)
+                {
+                    char *pstDataR = NULL;
+                    char *pstDataG = NULL;
+                    char *pstDataB = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8SC3);
+
+                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else if(iItem==4)
+                {
+                    char *pstDataR = NULL;
+                    char *pstDataG = NULL;
+                    char *pstDataB = NULL;
+                    char *pstDataA = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the A values
+                    sciErr = getMatrixOfInteger8InList(pvApiCtx, piAddr, 4, &iRows, &iCols, &pstDataA);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8SC4);
+
+                    /*Now that we have the 4 matrices(R,G,B,A), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec4b>(i,j)[3]=pstDataA[i+iRows*j];
+                          image.at<Vec4b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec4b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec4b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    unsigned char *pstDataR = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC1);
+
+                    //Assigning matrix value to pixel
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_UINT16: //for unsigned integer 16
+            {
+                if(iItem==2)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 16-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC2);
+
+                    //Now that we have the 2 matrices(R,G), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec2s>(i,j)[1]=pstDataR[i+iRows*j];
+                          image.at<Vec2s>(i,j)[0]=pstDataG[i+iRows*j];
+                          
+                        }
+                    }
+                }
+                else if(iItem==3)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    short unsigned int *pstDataB = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                     //i+iRows*j
+                        }
+                    }
+                }
+                
+                else if(iItem==4)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    short unsigned int *pstDataB = NULL;
+                    short unsigned int *pstDataA = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the A values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 4, &iRows, &iCols, &pstDataA);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC4);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec4s>(i,j)[3]=pstDataA[i+iRows*j];
+                          image.at<Vec4s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec4s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec4s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }                
+                else
+                {
+                    short unsigned int *pstDataR = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC1);
+
+                    //Assigning matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_INT16: //for signed integer 16
+            {
+                if(iItem==2)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC2);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec2s>(i,j)[1]=pstDataR[i+iRows*j];
+                          image.at<Vec2s>(i,j)[0]=pstDataG[i+iRows*j];                          
+                        }
+                    }
+                }
+                else if(iItem==3)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    short int *pstDataB = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else if(iItem==4)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    short int *pstDataB = NULL;
+                    short int *pstDataA = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 4, &iRows, &iCols, &pstDataA);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC4);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec4s>(i,j)[3]=pstDataA[i+iRows*j];
+                          image.at<Vec4s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec4s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec4s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    short int *pstDataR = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC1);
+
+                    //Assigning image matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<short>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+       
+            case SCI_INT32: //for signed integer 32
+            {
+                if(iItem==2)
+                {
+                    int *pstDataR = NULL;
+                    int *pstDataG = NULL;
+                    
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_32SC2);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec2i>(i,j)[1]=pstDataR[i+iRows*j];
+                          image.at<Vec2i>(i,j)[0]=pstDataG[i+iRows*j];                          
+                        }
+                    }
+                }
+                else if(iItem==3)
+                {
+                    int *pstDataR = NULL;
+                    int *pstDataG = NULL;
+                    int *pstDataB = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_32SC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3i>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3i>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3i>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else if(iItem==4)
+                {
+                    int *pstDataR = NULL;
+                    int *pstDataG = NULL;
+                    int *pstDataB = NULL;
+                    int *pstDataA = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the G values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the B values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 4, &iRows, &iCols, &pstDataA);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_32SC4);
+
+                    //Now that we have the 4 matrices(R,G,B,A), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec4i>(i,j)[3]=pstDataA[i+iRows*j];
+                          image.at<Vec4i>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec4i>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec4i>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    int *pstDataR = NULL;
+                    //retrive the matrix of the R values
+                    sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_32SC1);
+
+                    //Assigning image matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<int>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+           }
+        }
+    }
+            
+
+    else //for floating point/ double precision values
+    {
+        if(iItem==2)
+        {
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            
+            //retrive the matrix of the R values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the G values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC2);
+
+            //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    image.at<Vec2d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec2d>(i,j)[1]=pstDataG[i+iRows*j];
+                    
+                }
+            }
+        }
+        else if(iItem==3)
+        {
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            double *pstDataB = NULL;
+            
+            //retrive the matrix of the R values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the G values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the B values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+             
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC3);
+
+            //Now that we have the 4 matrices(R,G,B,A), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    
+                    image.at<Vec4d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec4d>(i,j)[1]=pstDataG[i+iRows*j];
+                    image.at<Vec4d>(i,j)[0]=pstDataB[i+iRows*j];
+                }
+            }
+        }
+        if(iItem==4)
+        {
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            double *pstDataB = NULL;
+            double *pstDataA = NULL;
+            //retrive the matrix of the R values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the G values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the B values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+             //retrive the matrix of the A values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 4, &iRows, &iCols, &pstDataA);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC4);
+
+            //Now that we have the 4 matrices(R,G,B,A), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    image.at<Vec4d>(i,j)[3]=pstDataA[i+iRows*j];
+                    image.at<Vec4d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec4d>(i,j)[1]=pstDataG[i+iRows*j];
+                    image.at<Vec4d>(i,j)[0]=pstDataB[i+iRows*j];
+                }
+            }
+        }
+        else
+        {
+            double *pstDataR = NULL;
+            //retrive the matrix of the R values
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC1);
+
+            //Assigning image matrix values to pixels
+            k=0;
+            for(i=0;i<iRows;i++)
+                for(j=0;j<iCols;j++)
+                    image.at<double>(i,j)=pstDataR[i+iRows*j];
+        }
+    }
+    return 1;
+}
+
+
+//function that returns an image matrix to the Scilab environment
+/*
+    What we now need, is to pass the image matrix to the Scilab environment.
+    We do this by passing a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int returnImage(char *checker,Mat img,int pos)
+{
+    int i,j,k=0;
+    int *piAddrNew  = NULL;
+    SciErr sciErr;
+    
+    int num=img.channels(); //num now contains no. of channels of the image
+    //creating the list that will be passed to the Scilab enviroment
+    if(num==1)
+    {
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 1, &piAddrNew);
+         if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);
+       return 0;
+    }
+        
+    }
+    else if(num==2)
+    {
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 2, &piAddrNew);
+         if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);
+       return 0;
+    }
+        
+        
+       }
+    else if(num==3)
+    {
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 3, &piAddrNew);
+         if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);
+       return 0;
+    }
+        
+        }
+    else if(num==4)
+    {
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 4, &piAddrNew);
+         if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);
+       return 0;
+    }
+        
+        }
+    else
+        sciprint("Image channel number not supported");
+        
+   
+    if(strcmp(checker,"8U")==0) //for Unsigned Integer 8
+    {
+    
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            
+
+            //The next block of code retrieves the RG values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2b intensity = img.at<Vec2b>(i, j);
+                    r [i+img.rows*j]=intensity.val[1];
+                    g [i+img.rows*j]=intensity.val[0];
+                    
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }            
+        }
+        
+        else if(num==3)
+        {
+        //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *b = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            
+
+            //The next block of code retrieves the RGBA values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3b intensity = img.at<Vec3b>(i, j);
+                    
+                    r [i+img.rows*j]=intensity.val[2];
+                    g [i+img.rows*j]=intensity.val[1];
+                    b [i+img.rows*j]=intensity.val[0];
+                   
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+        }
+        
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *b = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *a = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+
+            //The next block of code retrieves the RGBA values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec4b intensity = img.at<Vec4b>(i, j);
+                    a [i+img.rows*j]=intensity.val[3];
+                    r [i+img.rows*j]=intensity.val[2];
+                    g [i+img.rows*j]=intensity.val[1];
+                    b [i+img.rows*j]=intensity.val[0];
+                   
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //Adding the A value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols, a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<uchar>(i, j);
+
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"8S")==0) //for signed Integer 8
+    {
+    
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            char *r = (char *)malloc(img.rows * img.cols * sizeof(char));
+            char *g = (char *)malloc(img.rows * img.cols * sizeof(char));
+            
+
+            //The next block of code retrieves the RG values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2b intensity = img.at<Vec2b>(i, j);
+                    r [i+img.rows*j]=intensity.val[1];
+                    g [i+img.rows*j]=intensity.val[0];
+                    
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            
+        }
+        
+        else if(num==3)
+        {
+            
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            char *r = (char *)malloc(img.rows * img.cols * sizeof(char));
+            char *g = (char *)malloc(img.rows * img.cols * sizeof(char));
+            char *b = (char *)malloc(img.rows * img.cols * sizeof(char));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3b intensity = img.at<Vec3b>(i, j);
+                    r [i+img.rows*j]=intensity.val[2];
+                    g [i+img.rows*j]=intensity.val[1];
+                    b [i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            char *r = (char *)malloc(img.rows * img.cols * sizeof(char));
+            char *g = (char *)malloc(img.rows * img.cols * sizeof(char));
+            char *b = (char *)malloc(img.rows * img.cols * sizeof(char));
+            char *a = (char *)malloc(img.rows * img.cols * sizeof(char));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec4b intensity = img.at<Vec4b>(i, j);
+                    a [i+img.rows*j]=intensity.val[3];
+                    r [i+img.rows*j]=intensity.val[2];
+                    g [i+img.rows*j]=intensity.val[1];
+                    b [i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //Adding the A value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols, a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            char *r = (char *)malloc(img.rows * img.cols * sizeof(char));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<char>(i, j);
+
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"16U")==0) //for Unsigned Integer 16
+    {
+    
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2s intensity = img.at<Vec2s>(i, j);
+                    r[i+img.rows*j]=intensity.val[1];
+                    g[i+img.rows*j]=intensity.val[0];
+                    
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+        
+        else if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *b = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *b = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *a = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec4s intensity = img.at<Vec4s>(i, j);
+                    a[i+img.rows*j]=intensity.val[3];
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols, a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<ushort>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+    }
+    else if(strcmp(checker,"16S")==0) //for Signed Integer 16
+    {
+    
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2s intensity = img.at<Vec2s>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            
+        }
+        
+        else if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *b = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *b = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *a = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec4s intensity = img.at<Vec4s>(i, j);
+                    a[i+img.rows*j]=intensity.val[3];
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //Adding the A value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols,a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<short>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"32S")==0) //for Signed Integer 16
+    {
+    
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2i intensity = img.at<Vec2i>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+        }
+                
+        else if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *b = (int *)malloc(img.rows * img.cols * sizeof(int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3i intensity = img.at<Vec3i>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *b = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *a = (int *)malloc(img.rows * img.cols * sizeof(int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec4i intensity = img.at<Vec4i>(i, j);
+                    a[i+img.rows*j]=intensity.val[3];
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //Adding the A value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols,a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<int>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+
+    else if(strcmp(checker,"32F")==0) //for Float 32
+    {
+    
+    
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2d intensity = img.at<Vec2d>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }            
+        }
+        
+        else if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *a = (double *)malloc(img.rows * img.cols * sizeof(double));
+            
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec4d intensity = img.at<Vec4d>(i, j);
+                    a[i+img.rows*j]=intensity.val[3];
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //Adding the A value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols,a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<float>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    else if(strcmp(checker,"64F")==0) //For Float 64
+    {
+        
+        if(num==2)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec2d intensity = img.at<Vec2d>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }            
+        }
+        
+        else if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        
+        else if(num==4)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *a = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    a[i+img.rows*j]=intensity.val[3];
+                    r[i+img.rows*j]=intensity.val[2];
+                    g[i+img.rows*j]=intensity.val[1];
+                    b[i+img.rows*j]=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //Adding the A value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 4, img.rows,img.cols, a);
+            free(a);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    r[i+img.rows*j]=img.at<double>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+
+}
diff --git a/sci_gateway1/cpp/common3.cpp b/sci_gateway1/cpp/common3.cpp
new file mode 100644
index 0000000..45879a4
--- /dev/null
+++ b/sci_gateway1/cpp/common3.cpp
@@ -0,0 +1,925 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+//takes the matrix type as parameter and returns a string of the type
+string type2str(int type) 
+{
+    string r;
+    uchar depth = type & CV_MAT_DEPTH_MASK;
+    switch ( depth )
+    {
+        case CV_8U:  r = "8U"; break;
+        case CV_8S:  r = "8S"; break;
+        case CV_16U: r = "16U"; break;
+        case CV_16S: r = "16S"; break;
+        case CV_32S: r = "32S"; break;
+        case CV_32F: r = "32F"; break;
+        case CV_64F: r = "64F"; break;
+        default:     r = "User"; break;
+    }
+    return r;
+}
+
+//takes matrix type as parameter and returns no. of channels of the image matrix
+int no_of_channels(int type)
+{
+    uchar chans = 1 + (type >> CV_CN_SHIFT);
+    return chans;
+}
+
+//function used to retrieve image matrix from Scilab environment
+/*
+    We need to retrieve image from the Scilab environment
+    We do this by getting a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int retrieveImage(Mat &image,int pos)
+{
+
+    SciErr sciErr;
+    int iRows=0,iCols=0,i,j,k=0;
+    int *piAddr = NULL;
+    int *piAddr1 = NULL;
+    int *piAddrChild = NULL;
+    int iPrec = 0,iItem = 0;
+    int r=0,c=0;
+
+    //retrieving number of items in the list and type of data(integer/float)
+    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+    
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piAddrChild);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+    
+    
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    if(isIntegerType(pvApiCtx, piAddrChild))
+    {
+        //getting precision
+        sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrChild, &iPrec);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        switch(iPrec)
+        {
+            case SCI_UINT8: //for unsigned integer 8
+            {
+                
+                if(iItem==3)
+                {
+                    unsigned char *pstDataR = NULL;
+                    unsigned char *pstDataG = NULL;
+                    unsigned char *pstDataB = NULL; 
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    sciprint("testing");
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    for(r=0;r<iRows;r++)
+                                    {
+                                        for (c=0;c<iCols;c++)
+                                        {                                
+                                            sciprint("m=%d\n",pstDataR[r+iRows*c]);
+                                        }                            
+                                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    
+                                                 
+                                
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC3);
+
+                    /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    unsigned char *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_8UC1);
+
+                    //Assigning matrix value to pixel
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_UINT16: //for unsigned integer 16
+            {
+                
+                if(iItem==3)
+                {
+                    short unsigned int *pstDataR = NULL;
+                    short unsigned int *pstDataG = NULL;
+                    short unsigned int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                     //i+iRows*j
+                        }
+                    }
+                }
+                else
+                {
+                    short unsigned int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16UC1);
+
+                    //Assigning matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+            case SCI_INT16: //for signed integer 16
+            {
+                
+                if(iItem==3)
+                {
+                    short int *pstDataR = NULL;
+                    short int *pstDataG = NULL;
+                    short int *pstDataB = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the G values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive address of the list
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }   
+                    //retrive the matrix of the B values 
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC3);
+
+                    //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                    {
+                        for(j=0;j<iCols;j++)
+                        {
+                          image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                          image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                          image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                        }
+                    }
+                }
+                else
+                {
+                    short int *pstDataR = NULL;
+                    sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+                    if(sciErr.iErr)   
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    //retrive the matrix of the R values   
+                    sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    
+                    //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                    image = Mat(iRows,iCols,CV_16SC1);
+
+                    //Assigning image matrix values to pixels
+                    k=0;
+                    for(i=0;i<iRows;i++)
+                        for(j=0;j<iCols;j++)
+                          image.at<short>(i,j)=pstDataR[i+iRows*j];
+                }
+                break;
+            }
+        }
+    }
+    else //for floating point/ double precision values
+    {
+        
+        if(iItem==3)
+        {
+            
+            double *pstDataR = NULL;
+            double *pstDataG = NULL;
+            double *pstDataB = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }               
+            
+            //retrive the matrix of the G values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive address of the list
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }   
+            
+            //retrive the matrix of the B values 
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC3);
+
+            //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+            k=0;
+            for(i=0;i<iRows;i++)
+            {
+                for(j=0;j<iCols;j++)
+                {
+                    image.at<Vec3d>(i,j)[2]=pstDataR[i+iRows*j];
+                    image.at<Vec3d>(i,j)[1]=pstDataG[i+iRows*j];
+                    image.at<Vec3d>(i,j)[0]=pstDataB[i+iRows*j];
+                }
+            }
+            
+        }
+        else
+        {
+            
+            double *pstDataR = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx,pos,&piAddr1);
+            if(sciErr.iErr)   
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            //retrive the matrix of the R values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr1, 1, &iRows, &iCols, &pstDataR);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            
+            //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+            image = Mat(iRows,iCols,CV_64FC1);
+
+            //Assigning image matrix values to pixels
+            k=0;
+            for(i=0;i<iRows;i++)
+                for(j=0;j<iCols;j++)
+                    image.at<double>(i,j)=pstDataR[i+iRows*j];
+        }
+    }
+    return 1;
+}
+
+//function that returns an image matrix to the Scilab environment
+/*
+    What we now need, is to pass the image matrix to the Scilab environment.
+    We do this by passing a List of 2-D matrices. The size of the list, in our case is known(either 3 or 1,
+    3 for a coloured image and 1 for a grayscale image), hence we do not require the dynamic capability of a list.
+    Incase of a 3-channel image, the first matrix will be a matrix with dimensions img.rows X img.cols, and will denote the R(red)
+    values of the image. Similarly, the second will have the G(green) values, and the third will have B(blue) values.
+    For a single-channeled image, we will have only a single matrix
+*/
+int returnImage(char *checker,Mat img,int pos)
+{
+    int i,j,k=0;
+    int *piAddrNew  = NULL;
+    SciErr sciErr;
+    int num=no_of_channels(img.type()); //num now contains no. of channels of the image
+    //creating the list that will be passed to the Scilab enviroment
+    if(num==3)
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 3, &piAddrNew);
+    else
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + pos, 1, &piAddrNew);
+    if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);           
+       return 0;
+    }
+    if(strcmp(checker,"8U")==0) //for Unsigned Integer 8
+    {
+        if(num==3)
+        {
+            
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *g = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            unsigned char *b = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3b intensity = img.at<Vec3b>(i, j);
+                    *(r + j*img.rows + i)=intensity.val[2];
+                    *(g + j*img.rows + i)=intensity.val[1];
+                    *(b + j*img.rows + i)=intensity.val[0];
+                }
+            }
+
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            unsigned char *r = (unsigned char *)malloc(img.rows * img.cols * sizeof(unsigned char));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<uchar>(i, j);
+
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"16U")==0) //for Unsigned Integer 16
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *g = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            short unsigned int *b = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short unsigned int *r = (short unsigned int *)malloc(img.rows * img.cols * sizeof(short unsigned int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<ushort>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfUnsignedInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+    }
+    else if(strcmp(checker,"16S")==0) //for Signed Integer 16
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *g = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            short int *b = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3s intensity = img.at<Vec3s>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols, g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            short int *r = (short int *)malloc(img.rows * img.cols * sizeof(short int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<short>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger16InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+    else if(strcmp(checker,"32S")==0) //for Signed Integer 16
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *g = (int *)malloc(img.rows * img.cols * sizeof(int));
+            int *b = (int *)malloc(img.rows * img.cols * sizeof(int));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3i intensity = img.at<Vec3i>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            int *r = (int *)malloc(img.rows * img.cols * sizeof(int));
+            
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<int>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        }
+    }
+
+    else if(strcmp(checker,"32F")==0) //for Float 32
+    {
+        if(num==3)
+        {
+            
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols,b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows+ j)=img.at<float>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1,img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    else if(strcmp(checker,"64F")==0) //For Float 64
+    {
+        
+        if(num==3)
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *g = (double *)malloc(img.rows * img.cols * sizeof(double));
+            double *b = (double *)malloc(img.rows * img.cols * sizeof(double));
+            //The next block of code retrieves the RGB values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+            {
+                for(j=0;j<img.cols;j++)
+                {
+                    Vec3d intensity = img.at<Vec3d>(i, j);
+                    *(r + i*img.rows + j)=intensity.val[2];
+                    *(g + i*img.rows + j)=intensity.val[1];
+                    *(b + i*img.rows + j)=intensity.val[0];
+                }
+            }
+
+            //Adding the R value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols,r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the G value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 2, img.rows,img.cols,g);
+            free(g);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            //Adding the B value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 3, img.rows,img.cols, b);
+            free(b);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        else
+        {
+            //Since we need to pass a single pointer as an arguement, for a 2-D matrix, we define it in this manner
+            double *r = (double *)malloc(img.rows * img.cols * sizeof(double));
+
+            //The next block of code retrieves the image colour values at a specified pixel, and assigns it to the matrices
+            for(i=0;i<img.rows;i++)
+                for(j=0;j<img.cols;j++)
+                    *(r + i*img.rows + j)=img.at<double>(i, j);
+
+            //Adding the image colour value matrix to the list
+            sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+pos , piAddrNew, 1, img.rows,img.cols, r);
+            free(r);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+    }
+    
+}
diff --git a/sci_gateway1/cpp/libFOSSEE_Image_Processing_Toolbox.c b/sci_gateway1/cpp/libFOSSEE_Image_Processing_Toolbox.c
new file mode 100644
index 0000000..a504d15
--- /dev/null
+++ b/sci_gateway1/cpp/libFOSSEE_Image_Processing_Toolbox.c
@@ -0,0 +1,30 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <mex.h> 
+#include <sci_gateway.h>
+#include <api_scilab.h>
+#include <MALLOC.h>
+static int direct_gateway(char *fname,void F(void)) { F();return 0;};
+extern Gatefunc opencv_imread;
+static GenericTable Tab[]={
+  {(Myinterfun)sci_gateway,opencv_imread,"opencv_imread"},
+};
+ 
+int C2F(libFOSSEE_Image_Processing_Toolbox)()
+{
+  Rhs = Max(0, Rhs);
+  if (*(Tab[Fin-1].f) != NULL) 
+  {
+     if(pvApiCtx == NULL)
+     {
+       pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
+     }
+     pvApiCtx->pstName = (char*)Tab[Fin-1].name;
+    (*(Tab[Fin-1].f))(Tab[Fin-1].name,Tab[Fin-1].F);
+  }
+  return 0;
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/sci_gateway1/cpp/libFOSSEE_Image_Processing_Toolbox.so b/sci_gateway1/cpp/libFOSSEE_Image_Processing_Toolbox.so
new file mode 100755
index 0000000..3a6dc7a
--- /dev/null
+++ b/sci_gateway1/cpp/libFOSSEE_Image_Processing_Toolbox.so
diff --git a/sci_gateway1/cpp/libskeleton_imageprocessing.c b/sci_gateway1/cpp/libskeleton_imageprocessing.c
new file mode 100644
index 0000000..4fbf87c
--- /dev/null
+++ b/sci_gateway1/cpp/libskeleton_imageprocessing.c
@@ -0,0 +1,38 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <mex.h> 
+#include <sci_gateway.h>
+#include <api_scilab.h>
+#include <MALLOC.h>
+static int direct_gateway(char *fname,void F(void)) { F();return 0;};
+extern Gatefunc opencv_imread;
+extern Gatefunc opencv_imcrop;
+extern Gatefunc opencv_imresize;
+extern Gatefunc opencv_imsharpen;
+extern Gatefunc opencv_imwrite;
+static GenericTable Tab[]={
+  {(Myinterfun)sci_gateway_without_putlhsvar,opencv_imread,"opencv_imread"},
+  {(Myinterfun)sci_gateway_without_putlhsvar,opencv_imcrop,"opencv_imcrop"},
+  {(Myinterfun)sci_gateway_without_putlhsvar,opencv_imresize,"opencv_imresize"},
+  {(Myinterfun)sci_gateway_without_putlhsvar,opencv_imsharpen,"opencv_imsharpen"},
+  {(Myinterfun)sci_gateway_without_putlhsvar,opencv_imwrite,"opencv_imwrite"},
+};
+ 
+int C2F(libskeleton_imageprocessing)()
+{
+  Rhs = Max(0, Rhs);
+  if (*(Tab[Fin-1].f) != NULL) 
+  {
+     if(pvApiCtx == NULL)
+     {
+       pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
+     }
+     pvApiCtx->pstName = (char*)Tab[Fin-1].name;
+    (*(Tab[Fin-1].f))(Tab[Fin-1].name,Tab[Fin-1].F);
+  }
+  return 0;
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/sci_gateway1/cpp/libskeleton_imageprocessing.so b/sci_gateway1/cpp/libskeleton_imageprocessing.so
new file mode 100755
index 0000000..0902c8b
--- /dev/null
+++ b/sci_gateway1/cpp/libskeleton_imageprocessing.so
diff --git a/sci_gateway1/cpp/loader.sce b/sci_gateway1/cpp/loader.sce
new file mode 100644
index 0000000..15332b1
--- /dev/null
+++ b/sci_gateway1/cpp/loader.sce
@@ -0,0 +1,25 @@
+// This file is released under the 3-clause BSD license. See COPYING-BSD.
+// Generated by builder.sce : Please, do not edit this file
+// ----------------------------------------------------------------------------
+//
+libskeleton_imagepr_path = get_absolute_file_path('loader.sce');
+//
+// ulink previous function with same name
+[bOK, ilib] = c_link('libskeleton_imageprocessing');
+if bOK then
+  ulink(ilib);
+end
+//
+list_functions = [ 'opencv_imread';
+                   'opencv_imcrop';
+                   'opencv_imresize';
+                   'opencv_imsharpen';
+                   'opencv_imwrite';
+];
+addinter(libskeleton_imagepr_path + filesep() + 'libskeleton_imageprocessing' + getdynlibext(), 'libskeleton_imageprocessing', list_functions);
+// remove temp. variables on stack
+clear libskeleton_imagepr_path;
+clear bOK;
+clear ilib;
+clear list_functions;
+// ----------------------------------------------------------------------------
diff --git a/sci_gateway1/cpp/opencv_BRISKPoints.cpp b/sci_gateway1/cpp/opencv_BRISKPoints.cpp
new file mode 100644
index 0000000..224686d
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_BRISKPoints.cpp
@@ -0,0 +1,113 @@
+/***************************************************
+Author : Shashank Shekhar
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+    int opencv_BRISKPoints(char *fname, unsigned long fname_len)
+	{
+		SciErr sciErr;
+		int *piAddr = NULL;
+		int *piChild = NULL;
+		int iType = 0;
+		int iRows, iCols = 0;
+		double *matData = NULL;
+	
+		double *OrientationData = NULL;
+	    double *MetricData = NULL; 	
+		double *ScaleData = NULL;
+	
+	    CheckInputArgument(pvApiCtx, 1,1);	
+        CheckOutputArgument(pvApiCtx,1,5);
+
+       	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}      	
+		
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix || isVarComplex(pvApiCtx, piAddr))
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &matData);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}	
+
+		if (iCols!=2)
+        {
+            Scierror(999,"Invalid Argument\n");
+            return 0;
+        }
+
+	    OrientationData = (double *)malloc(sizeof(double)*iRows);
+	    MetricData = (double *)malloc(sizeof(double)*iRows);
+	    ScaleData = (double *)malloc(sizeof(double)*iRows);
+
+		for(int i = 0 ; i<iRows; i++)
+		{			
+		    OrientationData[i] = 0;
+		    MetricData[i] = 0;
+		    ScaleData[i] = 12;
+		}
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows,2, matData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRows,1, OrientationData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+	        
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows,1, MetricData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRows,1, ScaleData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    createScalarInteger32(pvApiCtx,nbInputArgument(pvApiCtx) + 5, iRows);
+
+	    for(int i=1;i<=5;i++)
+	    {
+	 		AssignOutputVariable(pvApiCtx, i) = nbInputArgument(pvApiCtx) + i;   	
+	    }
+
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_BlockMatcher.cpp b/sci_gateway1/cpp/opencv_BlockMatcher.cpp
new file mode 100644
index 0000000..654e5c8
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_BlockMatcher.cpp
@@ -0,0 +1,606 @@
+/***************************************************
+Author : Tanmay Chaudhari, Shashank Shekhar
+ ***************************************************/
+
+#include <bits/stdc++.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include "opencv2/highgui/highgui.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"
+	//#include "../common.cpp"
+	vector<pair<long double, pair<int, int > > > madv, msev;
+	vector<pair<pair<int, int>, pair<int, int > > > v;
+
+	int opencv_BlockMatcher(char *fname, unsigned long fname_len)
+	{	
+		//Error management variable
+		SciErr sciErr;
+
+		//Variable declaration
+		int maxm, itr;
+		int iRows = 0;
+		int iCols = 0;
+		int nbInputArguments = 0;	
+		int *piLen = NULL;
+		int *piAddr = NULL;
+		bool *providedArgs = NULL;
+		char *currentArg = NULL; 
+		char **pstData  = NULL;	
+		double *blocksize = NULL;
+		double *maximumDisplacement = NULL;
+		double *overlap = NULL;
+		double *horizontal = NULL;
+		double *vertical = NULL;
+		double *magnitude = NULL;
+		string s,t;
+		string matchCriteria;
+		string outputValue;
+		Mat img, img1, img2;
+
+		//Check input output arguments
+		CheckInputArgument(pvApiCtx, 2, 12);
+		CheckOutputArgument(pvApiCtx, 1, 1);
+
+		nbInputArguments = *getNbInputArgument(pvApiCtx);
+
+		if((nbInputArguments-2)%2!=0)
+		{
+			Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+			return 0; 
+		}
+
+		providedArgs = (bool*)malloc(sizeof(bool) * 5);
+		for(int i=0;i<5;i++)
+			providedArgs[i] = 0;
+
+		//Read image
+		//retrieveImage(img, 1);
+		//cvtColor(img, img1, CV_BGR2GRAY);
+		//retrieveImage(img, 2); 
+		//cvtColor(img, img2, CV_BGR2GRAY); 
+
+		//Reading first image
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		// Extracting name of next argument takes three calls to getMatrixOfString
+		sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+		sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+		for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+		{
+			pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+		}
+
+		sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		img1 = imread(pstData[0], CV_LOAD_IMAGE_GRAYSCALE);
+
+		//Reading second image
+		sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		// Extracting name of next argument takes three calls to getMatrixOfString
+		sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+		sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+		for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+		{
+			pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+		}
+
+		sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		img2 = imread(pstData[0], CV_LOAD_IMAGE_GRAYSCALE);
+
+		for(int iter=3;iter<=nbInputArguments;iter++)
+		{
+			// Getting address of next argument
+			sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			// Extracting name of next argument takes three calls to getMatrixOfString
+			sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+			sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+			for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+			{
+				pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+			}
+
+			sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			currentArg = pstData[0];
+			// providedArgs[] makes sure that no optional argument is provided more than once
+
+			if(strcmp(currentArg,"BlockSize")==0)
+			{
+				if(!providedArgs[0])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+					{
+						Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter); 
+						return 0; 
+					}
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &blocksize); 
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(iRows!=1 || iCols!=2)
+					{
+						Scierror(999, "Incorrect dimension of matrix for argument BlockSize.\n"); 
+						return 0; 
+					}
+					if(blocksize[0]<=0 || blocksize[1]<=0)
+					{
+						Scierror(999, "Positive inputs for BlockSize needed.\n"); 
+						return 0; 
+					}
+					providedArgs[0]=1;
+				}
+				else if(providedArgs[0])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}	
+			}
+			else if(strcmp(currentArg, "Overlap")==0)
+			{
+				if(!providedArgs[1])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+					{
+						Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter); 
+						return 0; 
+					}
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &overlap); 
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(iRows!=1 || iCols!=2)
+					{
+						Scierror(999, "Incorrect dimension of matrix for argument Overlap.\n"); 
+						return 0; 
+					}
+					if(overlap[0]<0 || overlap[1]<0)
+					{
+						Scierror(999, "Non-negative inputs for Overlap needed\n");
+						return 0;
+					}
+					providedArgs[1]=1;
+
+				}
+				else if(providedArgs[1])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}	
+			}
+			else if(strcmp(currentArg, "MaximumDisplacement")==0)
+			{
+				if(!providedArgs[2])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+					{
+						Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter); 
+						return 0; 
+					}
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &maximumDisplacement); 
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(iRows!=1 || iCols!=2)
+					{
+						Scierror(999, "Incorrect dimension of matrix for argument MaximumDisplacement.\n"); 
+						return 0; 
+					}
+					if(maximumDisplacement[0]<0 || maximumDisplacement[1]<0)
+					{
+						Scierror(999, "Non-negative inputs for Overlap needed\n");
+						return 0;
+					}
+					providedArgs[2]=1;
+
+				}
+				else if(providedArgs[2])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}	
+			}
+			else if(strcmp(currentArg, "MatchCriteria")==0)
+			{
+				if(!providedArgs[3])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+					sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+					for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+					{
+						pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					if(strcmp(pstData[0],"Mean square error")==0)
+						matchCriteria = "Mean Square Error";
+					else if(strcmp(pstData[0], "Mean absolute difference")==0)
+						matchCriteria = "	";
+					else
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are Mean square error or Mean absolute difference.\n", currentArg); 
+						return 0;
+					}
+					providedArgs[3]=1;
+				}
+				else if(providedArgs[3])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+			else if(strcmp(currentArg, "OutputValue")==0)
+			{
+				if(!providedArgs[4])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+					sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+					for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+					{
+						pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					if(strcmp(pstData[0],"Magnitude-squared")==0)
+						outputValue = "Magnitude-squared";
+					else if(strcmp(pstData[0], "Horizontal and vertical components")==0)
+						outputValue = "Horizontal and vertical components";
+					else
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are Magnitude-squared or Horizontal and vertical components.\n", currentArg); 
+						return 0;
+					}	
+					providedArgs[4]=1;
+				}
+				else if(providedArgs[4])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+		}
+
+		//Initialisaton
+		if(!providedArgs[0])
+		{
+			blocksize = (double*)malloc(sizeof(double) * 2);
+			blocksize[0] = 17;
+			blocksize[1] = 17;
+		}
+
+		if(!providedArgs[1])
+		{
+			overlap = (double*)malloc(sizeof(double) * 2);
+			overlap[0] = 0;
+			overlap[1] = 0;
+		}
+
+		if(!providedArgs[2])
+		{
+			maximumDisplacement = (double*)malloc(sizeof(double) * 2);
+			maximumDisplacement[0] = 7;
+			maximumDisplacement[1] = 7;
+		}
+
+		if(!providedArgs[3])
+		{
+			matchCriteria = "Mean Square Error";
+		}
+
+		if(!providedArgs[4])
+		{
+			outputValue = "Magnitude-squared";
+		}
+
+		if(outputValue == "Magnitude-squared")
+		{	
+			magnitude = (double*)malloc(sizeof(double) * int(img1.rows) * int(img1.cols));
+		}
+		else
+		{
+			horizontal = (double*)malloc(sizeof(double) * int(img1.rows) * int(img1.cols));
+			vertical = (double*)malloc(sizeof(double) * int(img1.rows) * int(img1.cols));
+		}
+
+		iRows = iCols = 0;
+		for(int i=0;i<int(img1.rows);i+=int(blocksize[0])-int(overlap[0]))
+		{
+			if(i+int(blocksize[0])>=int(img1.rows))
+				break;
+			for(int j=0;j<int(img1.cols);j+=int(blocksize[1])-int(overlap[1]))
+			{
+				if(j+int(blocksize[1])>=int(img1.cols))
+					break;
+				madv.clear();
+				msev.clear();
+				for(int k=-int(maximumDisplacement[0]);k<=int(maximumDisplacement[0]);k++)
+				{
+					if((i+k>=int(img2.rows)) || (i+k+int(blocksize[0])>=int(img2.rows)))
+						break;
+					if(i+k<0)
+						continue;
+					for(int l=-int(maximumDisplacement[1]);l<=int(maximumDisplacement[1]);l++)
+					{
+						if((j+l>=int(img2.cols)) || (j+l+int(blocksize[1])>=int(img2.cols)))
+							break;
+						if(j+l<0)
+							continue;
+
+						long double mad = 0;
+						long double mse = 0;
+								
+						for(int it1=0;it1<blocksize[0];it1++)
+						{
+							for(int it2=0;it2<blocksize[1];it2++)
+							{
+								long double cur1=img1.at<int>(i+it1,j+it2);
+								long double cur2=img2.at<int>(i+k+it1,j+l+it2);
+								long double error=cur1-cur2;
+								mad+=abs(error);
+								mad/=blocksize[0]*blocksize[1];
+								mse+=error*error;
+								mse/=blocksize[0]*blocksize[1];	
+							}
+						}
+						
+						madv.push_back(make_pair(mad,make_pair(i+k,j+l)));
+						msev.push_back(make_pair(mse,make_pair(i+k,j+l)));
+					}
+				}
+				if(outputValue == "Magnitude-squared")
+				{
+					sort(msev.begin(),msev.end());
+					if(msev.empty())
+						v.push_back(make_pair(make_pair(i,j),make_pair(i+int(blocksize[0]),j+int(blocksize[1]))));
+					else
+						v.push_back(make_pair(make_pair(i,j),msev[0].second));
+				}
+				else
+				{
+					sort(madv.begin(),madv.end());
+					if(madv.empty())
+						v.push_back(make_pair(make_pair(i,j),make_pair(i+int(blocksize[0]),j+int(blocksize[1]))));
+					else
+						v.push_back(make_pair(make_pair(i,j),madv[0].second));
+				}
+				iCols++;
+			}
+			iRows++;
+		}
+
+		if(outputValue == "Magnitude-squared")
+		{
+			//Creating list to store magnitude matrix in it
+			magnitude = (double*)malloc(sizeof(double) * int (v.size()));
+			for(int i=0;i<v.size();i++)
+			{
+				double mag = (v[i].second.first-v[i].first.first)*(v[i].second.first-v[i].first.first) + (v[i].second.second-v[i].first.second)*(v[i].second.second-v[i].first.second);
+				magnitude[i]=mag;
+			}
+
+			sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+			sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, iRows, (iCols/iRows), magnitude);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+		}
+		else
+		{
+			//Creating list to store horizontal and vertical matrix in it
+			horizontal = (double*)malloc(sizeof(double) * int(v.size()));
+			vertical = (double*)malloc(sizeof(double) * int(v.size()));
+			for(int i=0;i<v.size();i++)
+			{
+				horizontal[i] = v[i].second.first-v[i].first.first;
+				vertical[i] = v[i].second.second-v[i].first.second;
+			}
+
+			sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, &piAddr);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+			sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, iRows, (iCols/iRows), horizontal);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+			sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, iRows, (iCols/iRows), vertical);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+		}
+
+		//return output Arguments
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		madv.clear();
+		msev.clear();
+		v.clear();
+		return 0;
+	}
+	/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_CascadeObjectDetector.cpp b/sci_gateway1/cpp/opencv_CascadeObjectDetector.cpp
new file mode 100644
index 0000000..49adad4
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_CascadeObjectDetector.cpp
@@ -0,0 +1,431 @@
+/********************************************************
+Author: Diwakar Bhardwaj
+*********************************************************
+Usage :return_image=insertObjectAnnotation(input_image,'object')
+
+where object can be mouth,nose,ear or upperbody etc.
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_CascadeObjectDetector(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piLen = NULL;
+    char **object = NULL;
+    double *bboxes = NULL;
+    int i,j,k=0,l=0;
+    double alpha, beta,x,n;
+
+    CascadeClassifier face_cascade;
+    CascadeClassifier eyes_cascade;
+    CascadeClassifier mouth_cascade;
+    CascadeClassifier nose_cascade;
+    CascadeClassifier upperbody_cascade;
+
+    vector<Rect>faces,eyes,mouth,nose,upperbody;
+    face_cascade.load("/home/diwakar/Desktop/opencv-2.4.9/data/haarcascades/haarcascade_frontalface_alt.xml");
+    eyes_cascade.load("/home/diwakar/Desktop/opencv-2.4.9/data/haarcascades/haarcascade_mcs_eyepair_big.xml");
+    mouth_cascade.load("/home/diwakar/Desktop/opencv-2.4.9/data/haarcascades/haarcascade_mcs_mouth.xml");
+    nose_cascade.load("/home/diwakar/Desktop/opencv-2.4.9/data/haarcascades/haarcascade_mcs_nose.xml");
+    upperbody_cascade.load("/home/diwakar/Desktop/opencv-2.4.9/data/haarcascades/haarcascade_mcs_upperbody.xml");
+
+    float eye_x1,eye_y1,eye_x2,eye_y2,mouth_x1,mouth_y1,mouth_x2,mouth_y2,nose_x1,nose_y1,nose_x2,nose_y2;
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 2, 2);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    Mat image,new_image,image_gray;
+    
+    retrieveImage(image, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,2, &piAddr2);
+
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    object= (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        object[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen,object);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    int m;
+    double *bboxes = NULL;
+    bboxes = (double*)malloc(sizeof(double) * (int)answer.size() * 4);
+    int tbox=0;
+    //Converting image from rgb to gray scale image.
+    cvtColor( image, image_gray, CV_BGR2GRAY );
+    //equalizing the histrogram of gray scale image
+    equalizeHist( image_gray, image_gray );
+       
+    face_cascade.detectMultiScale( image, faces, 1.2,2,CV_HAAR_SCALE_IMAGE | CV_HAAR_DO_CANNY_PRUNING, cvSize(0,0), cvSize(255,255) );
+    if(strcmp(object[0],"face")==0)
+      {
+    for( int i = 0; i < faces.size(); i++ )
+       {    
+<<<<<<< HEAD
+       	   tbox = (int)faces.Size();
+       	   bboxes[i + 0 * (int)faces.size()] = faces[i].x;
+       	   bboxes[i + 1 * (int)faces.size()] = faces[i].y;
+       	   bboxes[i + 2 * (int)faces.size()] = faces[i].width;
+       	   bboxes[i + 3 * (int)faces.size()] = faces[i].height;
+=======
+>>>>>>> c6d5c3d8dbf4db6da6d7ac081918599b6977960a
+               
+           Point point1( faces[i].x + faces[i].width, faces[i].y + faces[i].height );
+           Point point2( faces[i].x, faces[i].y);
+           rectangle(image,point1,point2,cvScalar(0,255,0),1,16,0);
+<<<<<<< HEAD
+           Mat faceROI = image_gray( faces[i] );
+
+           eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+
+           for( int j = 0; j < eyes.size(); j++ )
+              {
+                  Point point3( faces[i].x + eyes[j].x + eyes[j].width, faces[i].y + eyes[j].y + eyes[j].height );
+                  Point point4(faces[i].x + eyes[j].x, faces[i].y + eyes[j].y );
+                  
+                  //rectangle(image,point3,point4,cvScalar(0,0,255),1,8,0);
+               }
+            eye_x1=faces[0].x + eyes[0].x + eyes[0].width;
+            eye_y1=faces[0].y + eyes[0].y + eyes[0].height;
+            eye_x2=faces[0].x + eyes[0].x;
+            eye_y2=faces[0].y + eyes[0].y;
+
+            nose_cascade.detectMultiScale( faceROI, nose, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < nose.size(); j++ )
+               {
+                    if((faces[i].x +nose[j].x + nose[j].width)<eye_x1 && (faces[i].y + nose[j].y + nose[j].height)>eye_y1)
+                    if((faces[i].x +nose[j].x)>eye_x2)     
+                       {
+                          Point point7(faces[i].x +nose[j].x + nose[j].width,faces[i].y + nose[j].y + nose[j].height );
+                          Point point8(faces[i].x +nose[j].x,faces[i].y+nose[j].y );
+                          
+                          //rectangle(image,point7,point8,cvScalar(255,255,0),1,8,0);
+                          m=j;
+                  
+                        } 
+                }
+
+            nose_x1=faces[0].x + nose[m].x + nose[m].width;
+            nose_y1=faces[0].y + nose[m].y + nose[m].height;
+            nose_x2=faces[0].x + nose[m].x;
+            nose_y2=faces[0].y + nose[m].y;
+            
+            mouth_cascade.detectMultiScale( faceROI, mouth, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < mouth.size(); j++ )
+               {
+     
+                  if((faces[i].x +mouth[j].x + mouth[j].width)<eye_x1 && (faces[i].x +mouth[j].x)>eye_x2)
+                    {
+                      if((faces[i].y + mouth[j].y + mouth[j].height)>(faces[i].y+nose[m].y +nose[m].height))
+                        {
+                          Point point5(faces[i].x +mouth[j].x + mouth[j].width,faces[i].y + mouth[j].y + mouth[j].height );
+                          Point point6(faces[i].x +mouth[j].x,faces[i].y + mouth[j].y );
+                         
+                          //rectangle(image,point5,point6,cvScalar(0,255,0),1,8,0);
+                          m=j;
+                        }
+                    }
+                }
+            mouth_x1=faces[0].x + mouth[m].x + mouth[m].width;
+            mouth_y1=faces[0].y + mouth[m].y + mouth[m].height;
+            mouth_x2=faces[0].x + mouth[m].x;
+            mouth_y2=faces[0].y + mouth[m].y;
+=======
+>>>>>>> c6d5c3d8dbf4db6da6d7ac081918599b6977960a
+      
+       }
+      }
+      else if(strcmp(object[0],"eyes")==0)
+      {
+    for( int i = 0; i < faces.size(); i++ )
+       {
+           Point point1( faces[i].x + faces[i].width, faces[i].y + faces[i].height );
+           Point point2( faces[i].x, faces[i].y);
+           //rectangle(image,point1,point2,cvScalar(0,255,0),1,16,0);
+           Mat faceROI = image_gray( faces[i] );
+
+           eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+
+           for( int j = 0; j < eyes.size(); j++ )
+              {
+                  Point point3( faces[i].x + eyes[j].x + eyes[j].width, faces[i].y + eyes[j].y + eyes[j].height );
+                  Point point4(faces[i].x + eyes[j].x, faces[i].y + eyes[j].y );
+                  
+                  rectangle(image,point3,point4,cvScalar(0,0,255),1,8,0);
+               }
+            eye_x1=faces[0].x + eyes[0].x + eyes[0].width;
+            eye_y1=faces[0].y + eyes[0].y + eyes[0].height;
+            eye_x2=faces[0].x + eyes[0].x;
+            eye_y2=faces[0].y + eyes[0].y;
+
+            nose_cascade.detectMultiScale( faceROI, nose, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < nose.size(); j++ )
+               {
+                    if((faces[i].x +nose[j].x + nose[j].width)<eye_x1 && (faces[i].y + nose[j].y + nose[j].height)>eye_y1)
+                    if((faces[i].x +nose[j].x)>eye_x2)     
+                       {
+                          Point point7(faces[i].x +nose[j].x + nose[j].width,faces[i].y + nose[j].y + nose[j].height );
+                          Point point8(faces[i].x +nose[j].x,faces[i].y+nose[j].y );
+                          
+                          //rectangle(image,point7,point8,cvScalar(255,255,0),1,8,0);
+                          m=j;
+                  
+                        } 
+                }
+
+            nose_x1=faces[0].x + nose[m].x + nose[m].width;
+            nose_y1=faces[0].y + nose[m].y + nose[m].height;
+            nose_x2=faces[0].x + nose[m].x;
+            nose_y2=faces[0].y + nose[m].y;
+            
+            mouth_cascade.detectMultiScale( faceROI, mouth, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < mouth.size(); j++ )
+               {
+     
+                  if((faces[i].x +mouth[j].x + mouth[j].width)<eye_x1 && (faces[i].x +mouth[j].x)>eye_x2)
+                    {
+                      if((faces[i].y + mouth[j].y + mouth[j].height)>(faces[i].y+nose[m].y +nose[m].height))
+                        {
+                          Point point5(faces[i].x +mouth[j].x + mouth[j].width,faces[i].y + mouth[j].y + mouth[j].height );
+                          Point point6(faces[i].x +mouth[j].x,faces[i].y + mouth[j].y );
+                         
+                          //rectangle(image,point5,point6,cvScalar(0,255,0),1,8,0);
+                          m=j;
+                        }
+                    }
+                }
+            mouth_x1=faces[0].x + mouth[m].x + mouth[m].width;
+            mouth_y1=faces[0].y + mouth[m].y + mouth[m].height;
+            mouth_x2=faces[0].x + mouth[m].x;
+            mouth_y2=faces[0].y + mouth[m].y;
+      
+       }
+      }
+      else if(strcmp(object[0],"nose")==0)
+      {
+    for( int i = 0; i < faces.size(); i++ )
+       {
+           Point point1( faces[i].x + faces[i].width, faces[i].y + faces[i].height );
+           Point point2( faces[i].x, faces[i].y);
+           //rectangle(image,point1,point2,cvScalar(0,255,0),1,16,0);
+           Mat faceROI = image_gray( faces[i] );
+
+           eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+
+           for( int j = 0; j < eyes.size(); j++ )
+              {
+                  Point point3( faces[i].x + eyes[j].x + eyes[j].width, faces[i].y + eyes[j].y + eyes[j].height );
+                  Point point4(faces[i].x + eyes[j].x, faces[i].y + eyes[j].y );
+                  
+                  //rectangle(image,point3,point4,cvScalar(0,0,255),1,8,0);
+               }
+            eye_x1=faces[0].x + eyes[0].x + eyes[0].width;
+            eye_y1=faces[0].y + eyes[0].y + eyes[0].height;
+            eye_x2=faces[0].x + eyes[0].x;
+            eye_y2=faces[0].y + eyes[0].y;
+
+            nose_cascade.detectMultiScale( faceROI, nose, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < nose.size(); j++ )
+               {
+                    if((faces[i].x +nose[j].x + nose[j].width)<eye_x1 && (faces[i].y + nose[j].y + nose[j].height)>eye_y1)
+                    if((faces[i].x +nose[j].x)>eye_x2)     
+                       {
+                          Point point7(faces[i].x +nose[j].x + nose[j].width,faces[i].y + nose[j].y + nose[j].height );
+                          Point point8(faces[i].x +nose[j].x,faces[i].y+nose[j].y );
+                          
+                          rectangle(image,point7,point8,cvScalar(255,255,0),1,8,0);
+                          m=j;
+                  
+                        } 
+                }
+
+            nose_x1=faces[0].x + nose[m].x + nose[m].width;
+            nose_y1=faces[0].y + nose[m].y + nose[m].height;
+            nose_x2=faces[0].x + nose[m].x;
+            nose_y2=faces[0].y + nose[m].y;
+            
+            mouth_cascade.detectMultiScale( faceROI, mouth, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < mouth.size(); j++ )
+               {
+     
+                  if((faces[i].x +mouth[j].x + mouth[j].width)<eye_x1 && (faces[i].x +mouth[j].x)>eye_x2)
+                    {
+                      if((faces[i].y + mouth[j].y + mouth[j].height)>(faces[i].y+nose[m].y +nose[m].height))
+                        {
+                          Point point5(faces[i].x +mouth[j].x + mouth[j].width,faces[i].y + mouth[j].y + mouth[j].height );
+                          Point point6(faces[i].x +mouth[j].x,faces[i].y + mouth[j].y );
+                          //rectangle(image,point5,point6,cvScalar(0,255,0),1,8,0);
+                          m=j;
+                        }
+                    }
+                }
+            mouth_x1=faces[0].x + mouth[m].x + mouth[m].width;
+            mouth_y1=faces[0].y + mouth[m].y + mouth[m].height;
+            mouth_x2=faces[0].x + mouth[m].x;
+            mouth_y2=faces[0].y + mouth[m].y;
+      
+       }
+      }
+      else if(strcmp(object[0],"mouth")==0)
+      {
+    for( int i = 0; i < faces.size(); i++ )
+       {
+           Point point1( faces[i].x + faces[i].width, faces[i].y + faces[i].height );
+           Point point2( faces[i].x, faces[i].y);
+           //rectangle(image,point1,point2,cvScalar(0,255,0),1,16,0);
+           Mat faceROI = image_gray( faces[i] );
+
+           eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+
+           for( int j = 0; j < eyes.size(); j++ )
+              {
+                  Point point3( faces[i].x + eyes[j].x + eyes[j].width, faces[i].y + eyes[j].y + eyes[j].height );
+                  Point point4(faces[i].x + eyes[j].x, faces[i].y + eyes[j].y );
+                  
+                  //rectangle(image,point3,point4,cvScalar(0,0,255),1,8,0);
+               }
+            eye_x1=faces[0].x + eyes[0].x + eyes[0].width;
+            eye_y1=faces[0].y + eyes[0].y + eyes[0].height;
+            eye_x2=faces[0].x + eyes[0].x;
+            eye_y2=faces[0].y + eyes[0].y;
+
+            nose_cascade.detectMultiScale( faceROI, nose, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < nose.size(); j++ )
+               {
+                    if((faces[i].x +nose[j].x + nose[j].width)<eye_x1 && (faces[i].y + nose[j].y + nose[j].height)>eye_y1)
+                    if((faces[i].x +nose[j].x)>eye_x2)     
+                       {
+                          Point point7(faces[i].x +nose[j].x + nose[j].width,faces[i].y + nose[j].y + nose[j].height );
+                          Point point8(faces[i].x +nose[j].x,faces[i].y+nose[j].y );
+                          
+                          //rectangle(image,point7,point8,cvScalar(255,255,0),1,8,0);
+                          m=j;
+                  
+                        } 
+                }
+
+            nose_x1=faces[0].x + nose[m].x + nose[m].width;
+            nose_y1=faces[0].y + nose[m].y + nose[m].height;
+            nose_x2=faces[0].x + nose[m].x;
+            nose_y2=faces[0].y + nose[m].y;
+            mouth_cascade.detectMultiScale( faceROI, mouth, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
+            for( int j = 0; j < mouth.size(); j++ )
+               {
+                  if((faces[i].x +mouth[j].x + mouth[j].width)<eye_x1 && (faces[i].x +mouth[j].x)>eye_x2)
+                    {
+                      if((faces[i].y + mouth[j].y + mouth[j].height)>(faces[i].y+nose[m].y +nose[m].height))
+                        {
+                          Point point5(faces[i].x +mouth[j].x + mouth[j].width,faces[i].y + mouth[j].y + mouth[j].height );
+                          Point point6(faces[i].x +mouth[j].x,faces[i].y + mouth[j].y );
+                          //if(strcmp(object[0],"mouth")==0)
+                          rectangle(image,point5,point6,cvScalar(0,255,0),1,8,0);
+                          m=j;
+                        }
+                    }
+                }
+            mouth_x1=faces[0].x + mouth[m].x + mouth[m].width;
+            mouth_y1=faces[0].y + mouth[m].y + mouth[m].height;
+            mouth_x2=faces[0].x + mouth[m].x;
+            mouth_y2=faces[0].y + mouth[m].y;
+      
+       }
+      }
+     else if(strcmp(object[0],"upper_body")==0)
+     {
+        upperbody_cascade.detectMultiScale( image_gray, upperbody, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(255, 255) );
+    
+        for( int i = 0; i < upperbody.size(); i++ )
+           {
+        Rect t = upperbody[i];
+        t.y += 100;
+        rectangle(image, t, Scalar(255,255,255), 4, 8);
+           }
+     }
+     else
+    {
+     sciprint("Wrong object type");
+
+    }
+
+    //new_image=image;
+    
+ 
+
+<<<<<<< HEAD
+    /*int temp = nbInputArgument(pvApiCtx) + 1;
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); */
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, tbox, 4, bboxes);
+=======
+    int temp = nbInputArgument(pvApiCtx) + 1;
+    string tempstring = type2str(image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,image,1);
+    free(checker); 
+    /*sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, tbox, 4, bboxes);
+>>>>>>> c6d5c3d8dbf4db6da6d7ac081918599b6977960a
+    if(sciErr.iErr){
+      printError(&sciErr, 0);
+      return 0;
+    }
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_DCT.cpp b/sci_gateway1/cpp/opencv_DCT.cpp
new file mode 100644
index 0000000..087c61b
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_DCT.cpp
@@ -0,0 +1,77 @@
+/********************************************************
+Author: Deepshikha
+return_image = DCT(source_image)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+using namespace std;
+
+extern "C"{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_DCT(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j;
+    int flags = 0;
+
+    /// checking input argument
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+
+    Mat image;
+    retrieveImage(image, 1);
+
+    if(image.channels() != 1){
+          Scierror(999, "Input should be single channel\n"); 
+          return 0; 
+    }
+    
+    /// even sized rows and columns required
+    if(image.rows%2 != 0){
+      Scierror(999, "%s:  Odd number of rows found\n");
+      return 0;
+    }
+    
+    if(image.cols%2 != 0){
+      Scierror(999, "%s:  Odd number of columns found\n");
+      return 0;
+    }
+
+    /// transformed_idct stores the transformed image
+    Mat new_image(image.rows, image.cols, image.type());
+    dct(image, new_image, flags);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker, new_image, 1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
+
diff --git a/sci_gateway1/cpp/opencv_Deinterlacer.cpp b/sci_gateway1/cpp/opencv_Deinterlacer.cpp
new file mode 100644
index 0000000..04db27f
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_Deinterlacer.cpp
@@ -0,0 +1,201 @@
+/********************************************************
+Author: Deepshikha
+return_image = Deinterlacer(source_image)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+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"
+  
+  int opencv_Deinterlacer(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    	int i, j, k , ch;
+    	int iRows=0;
+    	int iCols=0;
+    	int *piAddr2=NULL;
+    	int *piLen = 0;
+    	
+    	// to specify deinterlacing method
+    	char **method=NULL;
+
+    	/// checking input argument
+    	CheckInputArgument(pvApiCtx, 1, 2);
+   		CheckOutputArgument(pvApiCtx, 1, 1);
+
+    	vector <uint> v;
+
+    	Mat image;
+    	retrieveImage(image, 1);
+
+   		/// new_image contains deinterlaced image of original image
+    	Mat new_image(image.rows, image.cols, image.type());
+
+    	int nbInputArguments = *getNbInputArgument(pvApiCtx);
+    	if(nbInputArguments == 2)
+    	{
+      	sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+      	if(sciErr.iErr)
+    		{
+      		printError(&sciErr, 0);
+      		return 0;
+        }
+      	/// Retrieve string from input parameter. (requires 3 calls)
+      	/// first to retrieve dimensions
+      	sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, NULL, NULL);
+      	if(sciErr.iErr)
+      	{
+        	printError(&sciErr, 0);
+        	return 0;
+      	}
+    
+        //second call to retrieve length of each string    
+      	piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+      	sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+      	if(sciErr.iErr)
+      	{
+       		printError(&sciErr, 0);
+        	return 0;
+      	}
+
+      	method = (char**)malloc(sizeof(char*) * iRows * iCols);
+      	for(i = 0 ; i < iRows * iCols ; i++)
+        method[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+      	//third call to retrieve data
+      	sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, method);
+      	if(sciErr.iErr)
+      	{
+        	printError(&sciErr, 0);
+        	return 0;
+      	}
+      		
+      	// if second argument, method is Linear interpolation
+      	if(strcmp(method[0],"Linear interpolation")==0)
+      	{
+        	for(i = 0; i < image.rows; i++)
+        	{
+        		for(j = 0; j < image.cols; j++)
+        		{
+           		if(i == image.rows-1)
+            	{
+              	if(i%2!=0)
+                	new_image.at <uint> (i,j) = image.at <uint> (i-1,j);
+              	else
+                	new_image.at <uint> (i,j) = image.at <uint> (i,j);
+            	}
+            	else if(i%2 != 0 and i+1 < image.rows and i-1 >= 0)
+              	new_image.at <uint> (i,j) = ( image.at <uint> (i-1,j) + image.at <uint> (i+1,j) ) / 2;
+            	else
+              	new_image.at <uint> (i,j) = image.at <uint> (i,j);
+          	}
+        	}
+      	}
+
+        // if second argument, method is Vertical temporal median filtering
+      	else if(strcmp(method[0],"Vertical temporal median filtering")==0)
+      	{
+        	for(i = 0; i < image.rows; i++)
+        	{
+        		for(j = 0;j < image.cols; j++)
+          	{
+            	v.clear();
+            	if(i == image.rows-1)
+            	{
+              	if(i%2!=0)
+                  new_image.at <uint> (i,j) = image.at <uint> (i-1,j);
+              	else
+                  new_image.at <uint> (i,j) = image.at <uint> (i,j);
+            	}
+            	else if(i%2 != 0 and i-1 >= 0 and i+1 < image.rows)
+            	{
+              	v.push_back( image.at <uint> (i-1,j) );
+              	v.push_back( image.at <uint> (i,j) );
+              	v.push_back( image.at <uint> (i+1,j) );
+
+              	sort( v.begin(),v.end() ); // to find median 
+
+              	new_image.at <uint> (i,j) = v[1];
+            	}
+            	else
+              	new_image.at <uint> (i,j) = image.at <uint> (i,j);
+          	}
+        	}
+      	}
+        
+        // if second argument, method is Line repetition
+        else if(strcmp(method[0],"Line repetition")==0)
+        {
+          for( i = 0; i < image.rows; i++ )
+          {
+            for(j = 0; j < image.cols; j++ )
+            {
+              if( i == image.rows-1 and i%2!=0 )
+                new_image.at <uint> (i,j,k) = image.at <uint> (i,j,k);
+              if( i%2 != 0 and i-1 >=0 )
+                new_image.at <uint> (i,j,k) = image.at <uint> (i-1,j,k);
+              else
+                new_image.at <uint> (i,j, k) = image.at<uint> (i,j,k);
+            }
+          }
+        }
+      	// if any other invalid method name is passed as argument
+        else
+        {
+          Scierror(99,"Wrong method specified, use Linear interpolation or Vertical temporal median filtering or Line repetition as method name \n");
+          return 0;
+        }
+      }
+
+		  // if no of input argument is 1 that is no method is specified then we use Line repetition method by default
+      else
+    	{
+        for( i = 0; i < image.rows; i++ )
+      	{
+        	for(j = 0; j < image.cols; j++ )
+        	{
+          	if( i == image.rows-1 and i%2!=0 )
+            	new_image.at <uint> (i,j,k) = image.at <uint> (i,j,k);
+          	if( i%2 != 0 and i-1 >=0 )
+            	new_image.at <uint> (i,j,k) = image.at <uint> (i-1,j,k);
+          	else
+            	new_image.at <uint> (i,j, k) = image.at<uint> (i,j,k);
+        	}
+      	}
+     	}
+    
+      // writing to scilab memory
+      string tempstring = type2str(new_image.type());
+      char *checker;
+      checker = (char *)malloc(tempstring.size() + 1);
+      memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+      returnImage(checker, new_image, 1);
+      free(checker);
+
+      //Assigning the list as the Output Variable
+      AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+      //Returning the Output Variables as arguments to the Scilab environment
+      ReturnArguments(pvApiCtx);
+      return 0;
+  }
+/* ==================================================================== */
+}
+
diff --git a/sci_gateway1/cpp/opencv_FFT.cpp b/sci_gateway1/cpp/opencv_FFT.cpp
new file mode 100644
index 0000000..1ac386e
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_FFT.cpp
@@ -0,0 +1,89 @@
+/****************************************
+Author: Sridhar Reddy
+*****************************************/
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_fftnew(char *fname, unsigned long fname_len)
+  {
+  	SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0,i,j;
+    int *piAddr1=NULL;
+    double *ipReal=NULL;
+    double *ipImg=NULL;
+    double *rsltReal=NULL;
+    double *rsltImg=NULL;
+    vector<complex<double> > vec_out;
+    vector<double> vec_in;
+    
+  	CheckInputArgument(pvApiCtx, 1, 1);
+  	CheckOutputArgument(pvApiCtx, 1, 1) ;
+  	
+ 	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &iRows, &iCols, &ipReal);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	ipImg = (double*)malloc(sizeof(double) * iRows * iCols);
+	if(iRows==1){
+		for(i = 0 ; i <iCols ; i++)
+				vec_in.push_back(ipReal[i]);
+		dft(vec_in,vec_out, DFT_COMPLEX_OUTPUT);
+		for(i = 0 ; i < iCols ; i++){
+				ipReal[i]=real(vec_out[i]);
+				ipImg[i]=imag(vec_out[i]);
+			}
+		vec_in.clear();
+		vec_out.clear();
+			
+	}
+	else{
+		for(i = 0 ; i < iCols ; i++){
+			for(j = 0 ; j < iRows ; j++)
+				vec_in.push_back(ipReal[j+iCols*i]);
+			dft(vec_in,vec_out,DFT_COMPLEX_OUTPUT);
+			for(j = 0 ; j < iRows ; j++){
+				ipReal[j+iCols*i]=real(vec_out[j]);
+				ipImg[j+iCols*i]=imag(vec_out[j]);				
+			}
+			vec_in.clear();
+			vec_out.clear();
+		}
+	}
+		sciErr = allocComplexMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, &rsltReal, &rsltImg);	
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		for(i = 0 ; i < iRows * iCols; i++)
+			{	
+				rsltReal[i]=ipReal[i];
+				rsltImg[i]=ipImg[i];
+			}
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		return 0;
+  }
+}
diff --git a/sci_gateway1/cpp/opencv_ForegroundDetector.cpp b/sci_gateway1/cpp/opencv_ForegroundDetector.cpp
new file mode 100644
index 0000000..cd5bc9f
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_ForegroundDetector.cpp
@@ -0,0 +1,415 @@
+/***************************************************
+Author : Shashank Shekhar
+**************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"	
+#include <opencv2/video/background_segm.hpp>
+#include <iostream>
+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"
+    //#include "../common.cpp"
+
+    bool fdAdaptLearningRate;
+    double fdNumTrainingFrames=-1;
+    double fdLearningRate=-1;
+    double fdMinimumBackgroundRatio=-1;
+    double fdNumGaussians=-1;
+    int iBool;
+    bool objectStatus;
+    Ptr<BackgroundSubtractor> fdObj;
+
+	int opencv_ForegroundDetector(char *fname, unsigned long fname_len)
+	{
+
+        SciErr sciErr;
+        int *piAddr = NULL;
+        int *piAddrVal = NULL;
+        int iRows=0;
+        int iCols=0;
+        int flag;
+        int *piLen = NULL;
+        char **pstData = NULL;
+        char *currentArg = NULL;
+        int noOfarguments;
+        double tempLearningRate;
+        Ptr<BackgroundSubtractor> obj;
+        int val_position;
+        int iv_bool=false;
+        int argPresence[6];
+        for(int i=0;i<6;i++)
+            argPresence[i]=0;
+
+        CheckInputArgument(pvApiCtx, 0,10);
+        CheckOutputArgument(pvApiCtx,1,5);
+
+        noOfarguments = *getNbInputArgument(pvApiCtx);
+
+        if(noOfarguments%2!=0)
+        {
+            Scierror(999," Invalid No of Arguments \n");
+            return 0;
+        }
+
+//----------------------------------------------------------------- Retrieving Arguments -------------------------------------------------------------------------------
+        
+        for(int i=1;i<=noOfarguments;i+=2)
+        {
+
+    // first get the property
+            sciErr = getVarAddressFromPosition(pvApiCtx,i,&piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            if(!isStringType(pvApiCtx, piAddr))
+            {
+                Scierror(999,"Invalid Argument\n");
+                return 0;
+            }
+
+    //first call to get rows and columns 
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+            
+    //second call to retrieve length of each string
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+            for(int j = 0 ; j < iRows * iCols ; j++)
+            {
+                pstData[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));//+ 1 for null termination
+            }   
+    //third call to retrieve data
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            currentArg = pstData[0];
+
+            if(strcmp(currentArg, "AdaptLearningRate")==0)
+            {
+                val_position = i+1;
+
+                if(argPresence[0]==1)
+                {
+                    Scierror(999,"Do not enter the same parameter\n");
+                    return 0;
+                }
+
+                sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                if(!isBooleanType(pvApiCtx, piAddrVal))
+                {
+                    Scierror(999,"Invalid Value for AdaptLearningRate. A boolean value expected.\n");
+                    return 0;
+                }
+
+                if(!isScalar(pvApiCtx, piAddrVal))
+                {
+                    Scierror(999,"Invalid Value for AdaptLearningRate. A boolean value expected.\n");
+                    return 0;
+                } 
+                getScalarBoolean(pvApiCtx, piAddrVal, &iBool);
+                if(iBool == 0)
+                    fdAdaptLearningRate = false;
+                else
+                    fdAdaptLearningRate = true;
+
+                argPresence[0]=1;
+
+            }
+            else if(strcmp(currentArg, "NumTrainingFrames")==0)
+            {
+                val_position=i+1; 
+                
+                if(argPresence[1]==1)
+                {
+                    Scierror(999,"Do not enter the same parameter\n");
+                    return 0;
+                }
+
+                sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+                {
+                    Scierror(999," Invalid Value for NumTrainingFrames.\n");
+                    return 0;
+                }   
+        
+                getScalarDouble(pvApiCtx, piAddrVal, &fdNumTrainingFrames);
+                    
+                if(fdNumTrainingFrames<0)
+                {
+                    Scierror(999," Invalid Value for NumTrainingFrames. Enter a positive value\n");
+                    return 0;
+                }
+                argPresence[1]=1;        
+            }    
+            else if(strcmp(currentArg, "LearningRate")==0)
+            {
+                val_position=i+1; 
+                
+                if(argPresence[2]==1)
+                {
+                    Scierror(999,"Do not enter the same parameter\n");
+                    return 0;
+                }
+
+                sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+                {
+                    Scierror(999," Invalid Value for LearningRate.\n");
+                    return 0;
+                }   
+        
+                getScalarDouble(pvApiCtx, piAddrVal, &tempLearningRate);
+                    
+                if(tempLearningRate <0)
+                {
+                    Scierror(999," Invalid Value for LearningRate. Enter a positive value\n");
+                    return 0;
+                }
+                argPresence[2]=1;        
+            }
+            else if(strcmp(currentArg, "MinimumBackgroundRatio")==0)
+            {
+                val_position=i+1; 
+                
+                if(argPresence[3]==1)
+                {
+                    Scierror(999,"Do not enter the same parameter\n");
+                    return 0;
+                }
+
+                sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+                {
+                    Scierror(999," Invalid Value for MinimumBackgroundRatio.\n");
+                    return 0;
+                }   
+        
+                getScalarDouble(pvApiCtx, piAddrVal, &fdMinimumBackgroundRatio);
+                    
+                if(fdMinimumBackgroundRatio<0)
+                {
+                    Scierror(999," Invalid Value for MinimumBackgroundRatio. Enter a positive value\n");
+                    return 0;
+                }
+                argPresence[3]=1;        
+
+            }
+            else if(strcmp(currentArg, "NumGaussians")==0)
+            {
+                val_position=i+1; 
+                
+                if(argPresence[4]==1)
+                {
+                    Scierror(999,"Do not enter the same parameter\n");
+                    return 0;
+                }
+
+                sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+                {
+                    Scierror(999," Invalid Value for NumGaussians.\n");
+                    return 0;
+                }   
+        
+                getScalarDouble(pvApiCtx, piAddrVal, &fdNumGaussians);
+                    
+                if(fdNumGaussians<0)
+                {
+                    Scierror(999," Invalid Value for NumGaussians. Enter a positive value\n");
+                    return 0;
+                }
+                argPresence[4]=1;        
+
+            }
+            else
+            {
+                    Scierror(999,"Invalid Argument %s\n", currentArg);
+                    return 0;
+            }
+        }
+//      --------------------------------------------- End of OIA --------------------------------------------------------
+        if(argPresence[1]==0)
+            fdNumTrainingFrames = 150;
+        if(argPresence[2]==0)
+            fdLearningRate = 0.005;
+        if(argPresence[3]==0)
+            fdMinimumBackgroundRatio = 0.7;
+        if(argPresence[4]==0)
+            fdNumGaussians = 5;
+
+        fdObj = new BackgroundSubtractorMOG(fdNumTrainingFrames,fdNumGaussians,fdMinimumBackgroundRatio);
+        objectStatus = true;
+//      ------------------------------------------------------------------------------------------------------------------ 
+        if(fdAdaptLearningRate==true)
+            createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx)+1, 1);
+        else
+            createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx)+1, 0);
+
+        createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx)+2, fdNumTrainingFrames);
+        createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx)+3, fdMinimumBackgroundRatio);
+        createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx)+4, fdNumGaussians); 
+        createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx)+5, fdLearningRate);    
+
+        for(int i=1;i<=5;i++)
+        {
+            AssignOutputVariable(pvApiCtx, i) = nbInputArgument(pvApiCtx) + i;
+        }
+
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+
+    int opencv_readForegroundMask(char *fname, unsigned long fname_len)
+    {
+
+        SciErr sciErr;
+        int *piAddr = NULL;
+        int *outList = NULL;
+        unsigned char *red = NULL;
+        unsigned char *green = NULL;
+        unsigned char *blue = NULL; 
+
+        if(!objectStatus)
+        {
+            Scierror(999,"Set up Foreground Detection properties through Foreground Detector first.\n");
+            return 0;
+        }
+        CheckInputArgument(pvApiCtx, 1,1);
+        CheckOutputArgument(pvApiCtx,1,1);
+        Mat frame;
+        Mat foregoundMask;
+        retrieveImage(frame,1);
+        fdObj->operator()(frame, foregoundMask, fdLearningRate);
+    
+        if(foregoundMask.channels()==1)
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &outList);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            red = (unsigned char *)malloc(sizeof(unsigned char)*foregoundMask.rows*foregoundMask.cols);
+
+            for(int k=0;k<foregoundMask.rows;k++)
+                for(int p=0;p<foregoundMask.cols;p++)
+                    red[k+foregoundMask.rows*p]=foregoundMask.at<uchar>(k, p);
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, foregoundMask.rows, foregoundMask.cols, red);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }                       
+            free(red);
+        }
+        else
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, &outList);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            red = (unsigned char *)malloc(sizeof(unsigned char)*foregoundMask.rows*foregoundMask.cols);
+            green = (unsigned char *)malloc(sizeof(unsigned char)*foregoundMask.rows*foregoundMask.cols);
+            blue = (unsigned char *)malloc(sizeof(unsigned char)*foregoundMask.rows*foregoundMask.cols);
+
+            for(int k=0;k<foregoundMask.rows;k++)
+            {
+                for(int p=0;p<foregoundMask.cols;p++)
+                {
+                    Vec3b intensity = foregoundMask.at<Vec3b>(k, p);
+                    red[k+foregoundMask.rows*p]=intensity.val[2];
+                    green[k+foregoundMask.rows*p]=intensity.val[1];
+                    blue[k+foregoundMask.rows*p]=intensity.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, foregoundMask.rows, foregoundMask.cols, red);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 2, foregoundMask.rows, foregoundMask.cols, green);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }                   
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 3, foregoundMask.rows, foregoundMask.cols, blue);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            free(red);
+            free(green);
+            free(blue);
+        }
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;  
+        ReturnArguments(pvApiCtx);        
+
+        return 0;
+    }
+
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_GeometricShearer.cpp b/sci_gateway1/cpp/opencv_GeometricShearer.cpp
new file mode 100644
index 0000000..382de19
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_GeometricShearer.cpp
@@ -0,0 +1,178 @@
+/********************************************************
+Author: Diwakar Bhardwaj
+*********************************************************
+Usage :return_image=GeometricShearer(input_image,'direction',value)
+value is the amount want to shear the image in given direction 
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_GeometricShearer(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piLen = NULL;
+    char **direction = NULL;
+    int i,j,k;
+    double alpha, beta,x,n,value;
+    
+    
+     
+    //checking input argument
+    CheckInputArgument(pvApiCtx,3,3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    Mat image,new_image;
+    
+    retrieveImage(image, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,2, &piAddr2);
+
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    direction = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        direction[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, direction);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+     sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&value);
+    if(intErr)
+      return intErr;
+    
+    int r1, c1; // tranformed point
+    int rows, cols; // original image rows and columns
+    rows = image.rows;
+    cols = image.cols;
+    if(strcmp(direction[0], "Horizontal") == 0)
+    {
+          double Bx = value; 
+          double By = 0; 
+
+          int maxXOffset = abs(cols * Bx);
+          int maxYOffset = abs(rows * By);
+
+          Mat out = Mat::ones(image.rows+maxYOffset, image.cols+maxXOffset, image.type()); 
+
+          for(int r = 0; r < out.rows; r++)
+             {
+                for(int c = 0; c < out.cols; c++)
+                    {
+                        r1 = r + c * By - maxYOffset;
+                        c1 = r * Bx + c - maxXOffset;
+
+                        if(r1 >= 0 && r1 <= rows && c1 >= 0 && c1 <= cols)
+                          {
+                              out.at<uchar>(r, c) = image.at<uchar>(r1, c1);
+                           }
+
+                    }
+              }
+              int temp = nbInputArgument(pvApiCtx) + 1;
+              string tempstring = type2str(out.type());
+              char *checker;
+              checker = (char *)malloc(tempstring.size() + 1);
+              memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+              returnImage(checker,out,1);
+              free(checker); 
+     }
+     else if(strcmp(direction[0], "Vertical") == 0)
+    {            
+                double Bx = 0; 
+                double By = value; 
+
+                int maxXOffset = abs(cols * Bx);
+                int maxYOffset = abs(rows * By);
+
+                Mat out = Mat::ones(image.rows+maxYOffset, image.cols+maxXOffset, image.type()); 
+
+                for(int r = 0; r < out.rows; r++)
+                     {
+                       for(int c = 0; c < out.cols; c++)
+                           {
+                             r1 = r + c * By - maxYOffset;
+                             c1 = r * Bx + c - maxXOffset;
+
+                             if(r1 >= 0 && r1 <= rows && c1 >= 0 && c1 <= cols)
+                                {
+                                  out.at<uchar>(r, c) = image.at<uchar>(r1, c1);
+                                }
+
+                           }
+                      }
+                      int temp = nbInputArgument(pvApiCtx) + 1;
+                      string tempstring = type2str(out.type());
+                      char *checker;
+                      checker = (char *)malloc(tempstring.size() + 1);
+                      memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+                      returnImage(checker,out,1);
+                      free(checker); 
+
+    }
+    else
+     {
+      sciprint("Not valid 2nd argument");
+     }
+    
+
+    
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_HistogramBasedTracker.cpp b/sci_gateway1/cpp/opencv_HistogramBasedTracker.cpp
new file mode 100644
index 0000000..6d67886
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_HistogramBasedTracker.cpp
@@ -0,0 +1,257 @@
+/***************************************************
+Author : Tanmay Chaudhari
+ ***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <bits/stdc++.h>
+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"
+//#include "../common.cpp"
+
+	Mat image;
+	bool backprojMode = false;
+	bool selectObject = false;
+	int trackObject = 0;
+	Point origin;
+	Rect selection;
+	int vmin = 10, vmax = 256, smin = 30;
+    double xcord[1<<20];
+    double ycord[1<<20];
+    double width[1<<20];
+    double height[1<<20];
+    double orientation[1<<20];
+
+	static void onMouse( int event, int x, int y, int, void* )
+	{
+		if( selectObject )
+		{
+			selection.x = MIN(x, origin.x);
+			selection.y = MIN(y, origin.y);
+			selection.width = std::abs(x - origin.x);
+			selection.height = std::abs(y - origin.y);
+
+			selection &= Rect(0, 0, image.cols, image.rows);
+		}
+
+		switch( event )
+		{
+			case EVENT_LBUTTONDOWN:
+				origin = Point(x,y);
+				selection = Rect(x,y,0,0);
+				selectObject = true;
+				break;
+			case EVENT_LBUTTONUP:
+				selectObject = false;
+				if( selection.width > 0 && selection.height > 0 )
+					trackObject = -1;
+				break;
+		}
+	}
+	
+	int opencv_HistogramBasedTracker()
+	{	
+		SciErr sciErr;
+        int* piAddr = NULL;
+        int iRows = 0;
+        int iter = 0;
+        int iCols = 0;
+        int iRet = 0;
+        char** pstData = NULL;
+
+        CheckInputArgument(pvApiCtx, 1, 1);
+        CheckOutputArgument(pvApiCtx, 1, 2);
+
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        iRet = getAllocatedMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &pstData);
+        if(iRet)
+        {
+            freeAllocatedMatrixOfString(iRows, iCols, pstData);
+            return iRet;
+        }
+        sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pstData);
+        if(sciErr.iErr)
+        {
+            freeAllocatedMatrixOfString(iRows, iCols, pstData);
+            printError(&sciErr, 0);
+            return sciErr.iErr;
+        }
+		
+		VideoCapture cap(pstData[0]);
+		Rect trackWindow;
+		int hsize = 16;
+		float hranges[] = {0,180};
+		const float* phranges = hranges;
+		namedWindow( "Video Player", 0 );
+		setMouseCallback( "Video Player", onMouse, 0 );
+
+		Mat frame, hsv, hue, mask, hist, histimg = Mat::zeros(200, 320, CV_8UC3), backproj;
+		bool paused = false;
+
+		for(;;)
+		{
+			if( !paused)
+			{
+				cap >> frame;
+				if( frame.empty() )
+					break;
+			}
+
+			frame.copyTo(image);
+
+			if( !paused )
+			{
+				cvtColor(image, hsv, COLOR_BGR2HSV);
+
+				if( trackObject )
+				{
+					int _vmin = vmin, _vmax = vmax;
+
+					inRange(hsv, Scalar(0, smin, MIN(_vmin,_vmax)),
+							Scalar(180, 256, MAX(_vmin, _vmax)), mask);
+					int ch[] = {0, 0};
+					hue.create(hsv.size(), hsv.depth());
+					mixChannels(&hsv, 1, &hue, 1, ch, 1);
+
+					if( trackObject < 0 )
+					{
+						Mat roi(hue, selection), maskroi(mask, selection);
+						calcHist(&roi, 1, 0, maskroi, hist, 1, &hsize, &phranges);
+						normalize(hist, hist, 0, 255, NORM_MINMAX);
+
+						trackWindow = selection;
+						trackObject = 1;
+
+						histimg = Scalar::all(0);
+						int binW = histimg.cols / hsize;
+						Mat buf(1, hsize, CV_8UC3);
+						for( int i = 0; i < hsize; i++ )
+							buf.at<Vec3b>(i) = Vec3b(saturate_cast<uchar>(i*180./hsize), 255, 255);
+						cvtColor(buf, buf, COLOR_HSV2BGR);
+
+						for( int i = 0; i < hsize; i++ )
+						{
+							int val = saturate_cast<int>(hist.at<float>(i)*histimg.rows/255);
+							rectangle( histimg, Point(i*binW,histimg.rows),
+									Point((i+1)*binW,histimg.rows - val),
+									Scalar(buf.at<Vec3b>(i)), -1, 8 );
+						}
+					}
+
+					calcBackProject(&hue, 1, 0, hist, backproj, &phranges);
+					backproj &= mask;
+					RotatedRect trackBox = CamShift(backproj, trackWindow,
+							TermCriteria( TermCriteria::EPS | TermCriteria::COUNT, 10, 1 ));
+					if( trackWindow.area() <= 1 )
+					{
+						int cols = backproj.cols, rows = backproj.rows, r = (MIN(cols, rows) + 5)/6;
+						trackWindow = Rect(trackWindow.x - r, trackWindow.y - r,
+								trackWindow.x + r, trackWindow.y + r) &
+							Rect(0, 0, cols, rows);
+					}
+
+					if( backprojMode )
+						cvtColor( backproj, image, COLOR_GRAY2BGR );
+					ellipse( image, trackBox, Scalar(0,0,255), 3, 16 );
+					xcord[iter] = trackBox.center.x;
+					ycord[iter] = trackBox.center.y;
+					width[iter] = trackBox.size.width;
+					height[iter] = trackBox.size.height;
+					orientation[iter] = trackBox.angle;
+					iter++;	
+				}
+
+			}
+			else if( trackObject < 0 )
+				paused = false;
+
+			if( selectObject && selection.width > 0 && selection.height > 0 )
+			{
+				Mat roi(image, selection);
+				bitwise_not(roi, roi);
+			}
+			imshow( "Video Player", image );
+			char c = (char)waitKey(20);
+			if( c == 27 )
+				break;
+			else if(c == 32)
+				paused = !paused;
+			else;
+			waitKey(20);
+		}
+		destroyAllWindows();
+
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 4, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 1, iter, xcord);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, 1, iter, ycord);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, 1, iter, width);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 4, 1, iter, height);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, piAddr, 1, 1, iter, orientation);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+		ReturnArguments(pvApiCtx);
+		backprojMode = false;
+		selectObject = false;
+		trackObject = 0;
+		return 0;
+	}
+	/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_IDCT.cpp b/sci_gateway1/cpp/opencv_IDCT.cpp
new file mode 100644
index 0000000..a690982
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_IDCT.cpp
@@ -0,0 +1,72 @@
+/********************************************************
+Author: Suraj Prakash 
+return_image = IDCT(source_image)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+using namespace std;
+
+extern "C"{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_IDCT(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j;
+
+    int flags = 0;
+
+    /// checking input argument
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+
+    Mat image;
+    retrieveImage(image, 1);
+    
+    if(image.channels() != 1){
+    	Scierror(999, "%s: Image should be single channel\n");
+    	return 0;
+    }
+    /// even sized rows and columns required
+    if(image.rows%2 != 0 or image.cols%2 != 0){
+      Scierror(999, "%s: Either of rows size or column size is odd\n");
+      return 0;
+    }
+    
+    /// transformed_idct stores the transformed image
+    Mat transformed_idct(image.rows, image.cols, image.type());
+    idct(image, transformed_idct, flags);
+
+    string tempstring = type2str(transformed_idct.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker, transformed_idct, 1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
+
diff --git a/sci_gateway1/cpp/opencv_IFFT.cpp b/sci_gateway1/cpp/opencv_IFFT.cpp
new file mode 100644
index 0000000..6bbbcbc
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_IFFT.cpp
@@ -0,0 +1,69 @@
+/********************************************************
+Author: Diwakar
+return_image = IFFT(source_image)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+using namespace cv;
+using namespace std;
+
+extern "C"{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_IFFT(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j;
+   
+
+    /// checking input argument
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+
+    Mat img;
+    retrieveImage(img, 1);
+
+    if(img.channels()>2){
+          Scierror(999, "Input should be single or double channel\n"); 
+          return 0; 
+    }
+    Mat planes[] = {Mat_<float>(img), Mat::zeros(img.size(), CV_32F)};
+    Mat complexI;
+    merge(planes, 2, complexI);
+    dft(complexI, complexI);
+    Mat invDFT, invDFTcvt;
+    idft(complexI, invDFT, DFT_SCALE | DFT_REAL_OUTPUT );
+    invDFT.convertTo(invDFTcvt, CV_8U); 
+  
+    string tempstring = type2str(invDFTcvt.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,invDFTcvt, 1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
+
diff --git a/sci_gateway1/cpp/opencv_KalmanFilter.cpp b/sci_gateway1/cpp/opencv_KalmanFilter.cpp
new file mode 100644
index 0000000..4d1e317
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_KalmanFilter.cpp
@@ -0,0 +1,690 @@
+/********************************************************************************************************
+              Author : Kevin George
+
+-> Syntax : KalmanFilter("FileName(string)",..,"dynamParams(int)",..,"measureParams(int)",..,
+                            "controlParams(int)",..,"type(int)",..,"colour(string)",..)
+
+source-http://www.robot-home.it/blog/en/software/ball-tracker-con-filtro-di-kalman/ 
+*******************************************************************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"	
+#include <opencv2/video/background_segm.hpp>
+#include <iostream>
+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"
+    //#include "../common.cpp"
+    
+    int opencv_KalmanFilter(char *fname, unsigned long fname_len)
+    {
+
+        //Error variables
+        SciErr sciErr;
+        int intErr = 0;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+        //int *piAddr2 = NULL;
+
+        //-> Local variables
+        int num_InputArgs;  //-> gives total number of arguments
+        int iRows, iCols;
+        int *piLen = NULL;
+        char **pstData = NULL;  //-> why double pointer?? and what is it
+        char *currentArg = NULL; //-> Stores current string representing 'name' of name,value pair arguments
+        bool *providedArgs = NULL; //-> Used to check that optional argument is not entered more than once
+        //-> Name,Value Pair Variables
+            int dynamParams,measureParams;
+            int controlParams,type;
+            //char *colour = NULL;
+            string colour;
+            char *filename;
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        //-> Checks number of input and output arguments
+        CheckInputArgument(pvApiCtx, 0, 6);                     
+        CheckOutputArgument(pvApiCtx, 1, 6);                    
+
+        //-> Count number of input arguments
+        num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        providedArgs = (bool*) malloc(sizeof(bool) * 6);
+        
+        //-> Based on number of input arguments
+
+        for(int iter = 1; iter<= num_InputArgs; iter++)
+        {
+            //-> Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            //-> Extracting name of next argument takes three calls to getMatrixOfString
+            //-> First call to get rows and columns
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+            //-> Second call to retrieve length of each string
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+
+            //-> Third call to retrieve data
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            currentArg = pstData[0];
+            free(pstData);
+            iRows=0;
+            iCols=0;
+            free(piLen);
+
+//****************************************************** Name,Value - Filename *****************************************************************            
+            if(strcmp(currentArg, "FileName")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[5])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    //-> Extracting name of next argument takes three calls to getMatrixOfString
+                    //-> First call to get rows and columns
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+                    //-> Second call to retrieve length of each string
+                    sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+            
+                    pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+                    for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+                    {
+                        pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+                    }
+
+                    //-> Third call to retrieve data
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    filename = pstData[0];
+                    free(pstData);
+                    iRows=0;
+                    iCols=0;
+                    free(piLen);
+
+                   providedArgs[5] = 1;
+                }
+
+                else if(providedArgs[5]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+        
+            }
+//****************************************************** Name,Value - dynamParams *****************************************************************
+
+
+            if(strcmp(currentArg, "dynamParams")==0)
+            {
+
+                if(iter+1<= num_InputArgs && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &dynamParams); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    if( dynamParams < 0)
+                    {
+                        Scierror(999," Invalid Value for dynamParams. Please enter a non negative Double value\\n");
+                        return 0;
+                    }
+
+                   providedArgs[0] = 1;
+                }
+
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+//****************************************************** Name,Value - measureParams *****************************************************************
+            else if(strcmp(currentArg, "measureParams")==0)
+            {
+
+                if(iter+1<= num_InputArgs && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &measureParams); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    if( measureParams < 0)
+                    {
+                        Scierror(999," Invalid Value for measureParams. Please enter a non negative Double value\\n");
+                        return 0;
+                    }
+
+                   providedArgs[1] = 1;
+                }
+
+                else if(providedArgs[1]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+//****************************************************** Name,Value - controlParams *****************************************************************            
+
+            else if(strcmp(currentArg, "controlParams")==0)
+            {
+
+                if(iter+1<= num_InputArgs && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &controlParams); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    if( controlParams < 0)
+                    {
+                        Scierror(999," Invalid Value for controlParams. Please enter a non negative Double value\\n");
+                        return 0;
+                    }
+
+                   providedArgs[2] = 1;
+                }
+
+                else if(providedArgs[2]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+//****************************************************** Name,Value - type *****************************************************************            
+
+            else if(strcmp(currentArg, "type")==0)
+            {
+
+                if(iter+1<= num_InputArgs && !providedArgs[3])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &type); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+
+                   providedArgs[3] = 1;
+                }
+
+                else if(providedArgs[3]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+
+//****************************************************** Name,Value - colour *****************************************************************            
+
+
+            else if(strcmp(currentArg, "colour")==0)
+            {
+
+                if(iter+1<= num_InputArgs && !providedArgs[4])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    //-> Extracting name of next argument takes three calls to getMatrixOfString
+                    //-> First call to get rows and columns
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+                    //-> Second call to retrieve length of each string
+                    sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                
+                    pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+                    for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+                    {
+                        pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+                    }
+
+                    //-> Third call to retrieve data
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    colour = pstData[0];
+                    free(pstData);
+                    iRows=0;
+                    iCols=0;
+                    free(piLen);
+
+                   providedArgs[4] = 1;
+                }
+
+                else if(providedArgs[4]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+
+        }//-> Braces of big for loop
+    
+//******************************************************** Giving Default Arguments ******************************************************************* 
+
+        if(providedArgs[0] == 0)
+        {
+            dynamParams = 6;
+        }
+
+
+        if(providedArgs[1] == 0)
+        {
+            measureParams = 4;
+        }
+
+        if(providedArgs[2] == 0)
+        {
+            controlParams = 0;
+        }
+
+        if(providedArgs[3] == 0)
+        {
+            type = CV_32F;
+        }
+
+        if(providedArgs[4] == 0)
+        {
+            colour = "red";
+        }
+    	
+//**************************************************************Actual Processing*******************************************************************************
+
+        //objectStatus2 = true;
+        
+        //SciErr sciErr;
+        //int *piAddr = NULL;
+        //int *outList = NULL;
+        //unsigned char *red = NULL;
+        //unsigned char *green = NULL;
+        //unsigned char *blue = NULL; 
+    
+        KalmanFilter kf(dynamParams, measureParams, controlParams, type);
+
+        Mat state(dynamParams, 1, type);  // [x,y,v_x,v_y,w,h]
+        Mat meas(measureParams, 1, type);    // [z_x,z_y,z_w,z_h]
+
+        setIdentity(kf.transitionMatrix);
+
+        kf.measurementMatrix = cv::Mat::zeros(measureParams, dynamParams, type);
+        kf.measurementMatrix.at<float>(0) = 1.0f;
+        kf.measurementMatrix.at<float>(7) = 1.0f;
+        kf.measurementMatrix.at<float>(16) = 1.0f;
+        kf.measurementMatrix.at<float>(23) = 1.0f;
+
+        
+        kf.processNoiseCov.at<float>(0) = 1e-2;
+        kf.processNoiseCov.at<float>(7) = 1e-2;
+        kf.processNoiseCov.at<float>(14) = 5.0f;
+        kf.processNoiseCov.at<float>(21) = 5.0f;
+        kf.processNoiseCov.at<float>(28) = 1e-2;
+        kf.processNoiseCov.at<float>(35) = 1e-2;   
+
+        // Measures Noise Covariance Matrix R
+        setIdentity(kf.measurementNoiseCov, cv::Scalar(1e-1));
+        // <<<< Kalman Filter
+
+        VideoCapture cap(filename);
+        cap.set(CV_CAP_PROP_FRAME_WIDTH, 1024);
+        cap.set(CV_CAP_PROP_FRAME_HEIGHT, 768);
+
+        Mat frame;
+        //retrieveImage(frame,1);
+
+
+        char ch = 0;
+        double ticks = 0;
+        bool found = false;
+
+        int notFoundCount = 0;
+
+        //double precTick = ticks;
+        //-> measures a function execution time
+        //-> counting number of ticks after certain event
+        //ticks = (double) cv::getTickCount();
+
+        //double dT = (ticks - precTick) / cv::getTickFrequency(); //seconds
+
+        //Mat res;
+        //frame.copyTo( res );
+
+    while (ch != 'q' && ch != 'Q')    
+    {    
+        double precTick = ticks;
+        ticks = (double) cv::getTickCount();
+
+        double dT = (ticks - precTick) / cv::getTickFrequency(); //seconds
+
+        // Frame acquisition
+        cap >> frame;
+
+        cv::Mat res;
+        frame.copyTo( res );
+
+        if (found)
+        {
+            // >>>> Matrix A
+            kf.transitionMatrix.at<float>(2) = dT;
+            kf.transitionMatrix.at<float>(9) = dT;
+            // <<<< Matrix A
+
+            state = kf.predict();
+            
+            Rect predRect;
+            predRect.width = state.at<float>(4);
+            predRect.height = state.at<float>(5);
+            predRect.x = state.at<float>(0) - predRect.width / 2;
+            predRect.y = state.at<float>(1) - predRect.height / 2;
+
+            Point center;
+            center.x = state.at<float>(0);
+            center.y = state.at<float>(1);
+            circle(res, center, 2, CV_RGB(255,0,0), -1);
+
+            rectangle(res, predRect, CV_RGB(255,0,0), 2);
+        }
+
+        // >>>>> Noise smoothing
+        Mat blur;
+        GaussianBlur(frame, blur, cv::Size(5, 5), 3.0, 3.0);
+        // <<<<< Noise smoothing
+
+        // >>>>> HSV conversion
+        Mat frmHsv;
+        cvtColor(blur, frmHsv, CV_BGR2HSV);
+        // <<<<< HSV conversion
+
+        // >>>>> Color Thresholding
+        // Note: change parameters for different colors
+        Mat rangeRes = cv::Mat::zeros(frame.size(), CV_8UC1);
+        
+//************************** Tracks object with range of RGB values  *******************************************************************
+
+        if(colour == "red")
+        {    cv::inRange(frmHsv, cv::Scalar(0, 153, 127),
+                    cv::Scalar(4, 230, 179), rangeRes);
+        }
+
+        else if(colour == "green")
+        {
+            cv::inRange(frmHsv, cv::Scalar(30,0,0),
+                    cv::Scalar(100,255,255), rangeRes);
+        }
+
+        else if(colour == "white")
+        {
+            cv::inRange(frmHsv, cv::Scalar(0,0,80),
+                    cv::Scalar(255,50,120), rangeRes);
+        }
+
+        else if(colour == "orange" || colour == "yellow")
+        {
+            cv::inRange(frmHsv, cv::Scalar(15, 204, 204),
+                    cv::Scalar(20, 255, 255), rangeRes);
+        }
+
+
+
+        // <<<<< Color Thresholding
+
+        // >>>>> Improving the result
+        erode(rangeRes, rangeRes, cv::Mat(), cv::Point(-1, -1), 2);
+        dilate(rangeRes, rangeRes, cv::Mat(), cv::Point(-1, -1), 2);
+        // <<<<< Improving the result
+
+        // Thresholding viewing
+        ///cv::imshow("Threshold", rangeRes);
+
+        // >>>>> Contours detection
+        vector<vector<cv::Point> > contours;
+        findContours(rangeRes, contours, CV_RETR_EXTERNAL,
+                         CV_CHAIN_APPROX_NONE);
+        // <<<<< Contours detection
+
+        // >>>>> Filtering
+        vector<vector<cv::Point> > balls;
+        vector<cv::Rect> ballsBox;
+        
+        for (size_t i = 0; i < contours.size(); i++)
+        {
+            Rect bBox;
+            bBox = cv::boundingRect(contours[i]);
+
+            float ratio = (float) bBox.width / (float) bBox.height;
+            if (ratio > 1.0f)
+                ratio = 1.0f / ratio;
+
+            // Searching for a bBox almost square
+            if (ratio > 0.75 && bBox.area() >= 400)
+            {
+                balls.push_back(contours[i]);
+                ballsBox.push_back(bBox);
+            }
+        }
+        // <<<<< Filtering
+
+        // >>>>> Detection result
+        for (size_t i = 0; i < balls.size(); i++)
+        {
+            drawContours(res, balls, i, CV_RGB(20,150,20), 1);
+            rectangle(res, ballsBox[i], CV_RGB(0,255,0), 2);
+
+            Point center;
+            center.x = ballsBox[i].x + ballsBox[i].width / 2;
+            center.y = ballsBox[i].y + ballsBox[i].height / 2;
+            circle(res, center, 2, CV_RGB(20,150,20), -1);
+
+            stringstream sstr;
+            sstr << "(" << center.x << "," << center.y << ")";
+            putText(res, sstr.str(),
+                        cv::Point(center.x + 3, center.y - 3),
+                        cv::FONT_HERSHEY_SIMPLEX, 0.5, CV_RGB(20,150,20), 2);
+        }
+        // <<<<< Detection result
+
+        // >>>>> Kalman Update
+        if (balls.size() == 0)
+        {
+            notFoundCount++;
+            if( notFoundCount >= 100 )
+            {
+                found = false;
+            }
+            /*else
+                kf.statePost = state;*/
+        }
+        else
+        {
+            notFoundCount = 0;
+
+            meas.at<float>(0) = ballsBox[0].x + ballsBox[0].width / 2;
+            meas.at<float>(1) = ballsBox[0].y + ballsBox[0].height / 2;
+            meas.at<float>(2) = (float)ballsBox[0].width;
+            meas.at<float>(3) = (float)ballsBox[0].height;
+
+            if (!found) // First detection!
+            {
+                // >>>> Initialization
+                kf.errorCovPre.at<float>(0) = 1; // px
+                kf.errorCovPre.at<float>(7) = 1; // px
+                kf.errorCovPre.at<float>(14) = 1;
+                kf.errorCovPre.at<float>(21) = 1;
+                kf.errorCovPre.at<float>(28) = 1; // px
+                kf.errorCovPre.at<float>(35) = 1; // px
+
+                state.at<float>(0) = meas.at<float>(0);
+                state.at<float>(1) = meas.at<float>(1);
+                state.at<float>(2) = 0;
+                state.at<float>(3) = 0;
+                state.at<float>(4) = meas.at<float>(2);
+                state.at<float>(5) = meas.at<float>(3);
+                // <<<< Initialization
+
+                found = true;
+            }
+            else
+                kf.correct(meas); // Kalman Correction
+
+        }
+        // <<<<< Kalman Update  
+        // Final result
+        cv::imshow("Tracking", res);
+        ch = cv::waitKey(1);
+
+    }    
+        //AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;  
+        ReturnArguments(pvApiCtx);        
+
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_SURFPoints.cpp b/sci_gateway1/cpp/opencv_SURFPoints.cpp
new file mode 100644
index 0000000..93bd6c2
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_SURFPoints.cpp
@@ -0,0 +1,123 @@
+/***************************************************
+Author : Shashank Shekhar
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+    int opencv_SURFPoints(char *fname, unsigned long fname_len)
+	{
+		SciErr sciErr;
+		int *piAddr = NULL;
+		int *piChild = NULL;
+		int iType = 0;
+		int iRows, iCols = 0;
+		double *matData = NULL;
+	
+		double *OrientationData = NULL;
+	    double *MetricData = NULL;
+		int *LaplacianData = NULL;	    	
+		double *ScaleData = NULL;
+	
+	    CheckInputArgument(pvApiCtx, 1,1);	
+        CheckOutputArgument(pvApiCtx,1,6);
+
+       	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}      	
+		
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix || isVarComplex(pvApiCtx, piAddr))
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &matData);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}	 
+
+		if (iCols!=2)
+        {
+            Scierror(999,"Invalid Argument\n");
+            return 0;
+        }
+
+	    OrientationData = (double *)malloc(sizeof(double)*iRows);
+	    MetricData = (double *)malloc(sizeof(double)*iRows);
+	    LaplacianData = (int *)malloc(sizeof(int)*iRows);
+	    ScaleData = (double *)malloc(sizeof(double)*iRows);
+
+		for(int i = 0 ; i<iRows; i++)
+		{			
+		    OrientationData[i] = 0;
+		    MetricData[i] = 0;
+		    LaplacianData[i] = 0;
+		    ScaleData[i] = 1.6;
+		}
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows,2, matData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRows,1, OrientationData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+	        
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows,1, MetricData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+	 
+	    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRows,1, LaplacianData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows,1, ScaleData);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    createScalarInteger32(pvApiCtx,nbInputArgument(pvApiCtx) + 6, iRows);
+
+	    for(int i=1;i<=6;i++)
+	    {
+	 		AssignOutputVariable(pvApiCtx, i) = nbInputArgument(pvApiCtx) + i;   	
+	    }
+
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_TemplateMatcher.cpp b/sci_gateway1/cpp/opencv_TemplateMatcher.cpp
new file mode 100644
index 0000000..674abcb
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_TemplateMatcher.cpp
@@ -0,0 +1,146 @@
+/********************************************************
+Author: Suraj Prakash
+return_image = TemplateMatcher(InputArray image, InputArray templage_image, int method)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+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"
+  
+  int opencv_TemplateMatcher(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j;
+
+    int iRows = 0;
+    int iCols = 0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+
+    char **method = NULL;
+
+
+    /// checking input argument
+    CheckInputArgument(pvApiCtx, 2, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+    Mat image, template_image;
+    retrieveImage(image, 1);
+    retrieveImage(template_image, 2);
+
+    /// if there is inconsistency in data type of image and template image
+    if(type2str(image.type()) != type2str(template_image.type())){
+      Scierror(999, "%s: Image and template image are not of same type\n");
+      return 0;
+    }
+
+    if(template_image.rows > image.rows or template_image.cols > image.cols){
+      Scierror(999, "%s: Dimensions of template image is greater then image\n");
+      return 0;
+    }
+
+    /// generated image is (W - w + 1) * (H - h + 1) and it must be 32 bit floating number with single channel
+
+    Mat new_image(image.rows, image.cols, image.type()); 
+
+
+     int nbInputArguments = *getNbInputArgument(pvApiCtx);
+     if(nbInputArguments > 2){
+     		/// variable address
+		    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
+		    if(sciErr.iErr){   
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+		    
+		    /// Retrieve string from input parameter. (requires 3 calls)
+		    /// first to retrieve dimensions
+		    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+		    if(sciErr.iErr){
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+		    
+		    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+		    //second call to retrieve length of each string
+		    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+		    if(sciErr.iErr){
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+
+		    method = (char**)malloc(sizeof(char*) * iRows * iCols);
+		    for(i = 0 ; i < iRows * iCols ; i++)
+		        method[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+		    //third call to retrieve data
+		    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, method);
+		    if(sciErr.iErr){
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+
+		     if(strcmp(method[0], "CV_TM_SQDIFF") == 0)
+		      matchTemplate(image, template_image, new_image, CV_TM_SQDIFF);
+		    else if(strcmp(method[0], "CV_TM_SQDIFF_NORMED") == 0)
+		      matchTemplate(image, template_image, new_image, CV_TM_SQDIFF_NORMED);
+		    else if(strcmp(method[0], "CV_TM_CCORR") == 0)
+		      matchTemplate(image, template_image, new_image, CV_TM_CCORR);
+		    else if(strcmp(method[0], "CV_TM_CCORR_NORMED") == 0)
+		      matchTemplate(image, template_image, new_image, CV_TM_CCORR_NORMED);
+		    else if(strcmp(method[0], "CV_TM_CCOEFF") == 0)
+		      matchTemplate(image, template_image, new_image, CV_TM_CCOEFF);
+		    else if(strcmp(method[0], "CV_TM_CCOEFF_NORMED") == 0)
+		      matchTemplate(image, template_image, new_image, CV_TM_CCOEFF_NORMED);
+		    else{
+		      matchTemplate(image, template_image, new_image, CV_TM_SQDIFF);
+		      sciprint("Wrong method given, using CV_TM_SQDIFF instead");  
+    		}          
+     }
+
+     else{
+     	 matchTemplate(image, template_image, new_image, CV_TM_SQDIFF);
+     }
+    
+
+    
+
+
+     
+    
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker, new_image, 1);
+    free(checker);
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_VideoPlayer.cpp b/sci_gateway1/cpp/opencv_VideoPlayer.cpp
new file mode 100644
index 0000000..74b7405
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_VideoPlayer.cpp
@@ -0,0 +1,78 @@
+/***************************************************
+Author : Tanmay Chaudhari
+**************************************************/
+
+#include "opencv2/video/tracking.hpp"
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"   
+#include <iostream>
+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"
+    //#include "../common.cpp"
+
+    int opencv_VideoPlayer()
+    {   
+        SciErr sciErr;
+        int* piAddr = NULL;
+        int iRows = 0;
+        int iCols = 0;
+        int iRet = 0;
+        char** pstData = NULL;
+
+        CheckInputArgument(pvApiCtx, 1, 1);
+        CheckOutputArgument(pvApiCtx, 1, 1);
+
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        iRet = getAllocatedMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &pstData);
+        if(iRet)
+        {
+            freeAllocatedMatrixOfString(iRows, iCols, pstData);
+            return iRet;
+        }
+        sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, iCols, pstData);
+        if(sciErr.iErr)
+        {
+            freeAllocatedMatrixOfString(iRows, iCols, pstData);
+            printError(&sciErr, 0);
+            return sciErr.iErr;
+        }
+        VideoCapture cap(pstData[0]);
+        namedWindow("Video Player", 0 );
+        Mat frame;
+        bool paused = false;
+        for(;;)
+        {
+            if( !paused )
+            {
+                cap >> frame;
+                if(frame.empty())
+                    break;
+            }
+            imshow("Video Player", frame );
+            char c = (char)waitKey(20);
+            if(c==27)
+                break;
+            else if(c==32)
+                paused=!paused;
+            else;
+        }
+        destroyAllWindows();
+        ReturnArguments(pvApiCtx); 
+        return 0;
+    }
+}
+
diff --git a/sci_gateway1/cpp/opencv_VideoReader.cpp b/sci_gateway1/cpp/opencv_VideoReader.cpp
new file mode 100644
index 0000000..51207bf
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_VideoReader.cpp
@@ -0,0 +1,389 @@
+/***************************************************
+Author : Tanmay Chaudhari, Shashank Shekhar
+**************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"	
+#include <iostream>
+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"
+    //#include "../common.cpp"
+
+	Ptr<VideoCapture> capture;
+	double videoCurrentTime = 0;
+	double videoDuration = 0;
+	int videoFPS;
+	char *videoFileName = NULL;
+	bool videoObjectSt = false;
+	int opencv_VideoReader(char *fname, unsigned long fname_len)
+	{
+	    
+	    SciErr sciErr;
+	    int *piAddr = NULL;
+	    int *piAddrVal = NULL;
+	    int *piLen = NULL;
+	    int iRows, iCols = 0;
+	    char ** pstData1 = NULL;
+	    char ** pstData2 = NULL;
+	    double frames;
+	    double width;
+	    double height;
+	    double CT;
+	    char full_path[PATH_MAX];
+	    bool stillLeft = false;
+	    CheckInputArgument(pvApiCtx,1,3);
+	    CheckOutputArgument(pvApiCtx,1,10);	
+	    int noOfarguments = *getNbInputArgument(pvApiCtx);
+	    if(noOfarguments==2)
+	    {
+	        Scierror(999,"Invalid number of Arguments\n");
+	        return 0;
+	    }
+
+		sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+	    if (sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+	    if(!isStringType(pvApiCtx, piAddr))
+	    {
+	        Scierror(999,"Invalid Argument\n");
+	        return 0;
+	    }
+	    //first call to get rows and columns 
+	    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+	    piLen = (int*)malloc(sizeof(int) * iRows * iCols);  
+		//second call to retrieve length of each string
+	    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+	    pstData1 = (char**)malloc(sizeof(char*) * iRows * iCols);
+	    for(int j = 0 ; j < iRows * iCols ; j++)
+	    {
+	        pstData1[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));//+ 1 for null termination
+	    }
+		//third call to retrieve data
+	    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData1);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }   
+
+	    if(noOfarguments>1)
+	    {
+			sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr);
+		    if (sciErr.iErr)
+		    {
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+		    if(!isStringType(pvApiCtx, piAddr))
+		    {
+		        Scierror(999,"Invalid Argument\n");
+		        return 0;
+		    }
+		    //first call to get rows and columns 
+		    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+		    if(sciErr.iErr)
+		    {
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+		    piLen = (int*)malloc(sizeof(int) * iRows * iCols);  
+			//second call to retrieve length of each string
+		    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+		    if(sciErr.iErr)
+		    {
+		        printError(&sciErr, 0);
+		        return 0;
+		    }
+		    pstData2 = (char**)malloc(sizeof(char*) * iRows * iCols);
+		    for(int j = 0 ; j < iRows * iCols ; j++)
+		    {
+		        pstData2[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));//+ 1 for null termination
+		    }
+			//third call to retrieve data
+		    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData2);
+		    if(sciErr.iErr)
+		    {
+		        printError(&sciErr, 0);
+		        return 0;
+		    }   
+
+		    if(strcmp(pstData2[0], "CurrentTime")==0)
+		    {
+		    	sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddrVal);
+	            if (sciErr.iErr)
+	            {
+	                printError(&sciErr, 0);
+	                return 0;
+	            }
+
+		        if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+	            {
+		
+	                Scierror(999," Invalid Value for Current Time.\n");
+	                return 0;
+		        }       
+	 	        getScalarDouble(pvApiCtx, piAddrVal, &CT);
+	 	        if(CT<0)
+	 	        {
+			        Scierror(999,"Invalid Input for CurrentTime.\n");
+			        return 0;
+	 	        }
+	 	        CT*=1000;
+		    }
+		    else
+		    {
+		        Scierror(999,"Invalid Argument\n");
+		        return 0;	    	
+		    }
+		}
+
+	    if(videoObjectSt==true && strcmp(videoFileName, pstData1[0])==0)
+	    { 
+	    	if(int(videoCurrentTime) >= int(videoDuration))
+	    	{
+	 			stillLeft = false;
+	    	}
+	 		else if(int(videoCurrentTime) < int(videoDuration))
+	 			stillLeft = true;
+	    }
+
+	    if(!stillLeft)
+	   	{	
+	   		capture = new VideoCapture(pstData1[0]);
+			if(!capture->isOpened())
+		   	{
+			    Scierror(999,"Could not open file\n");
+		        return 0;
+		   	}
+		}
+
+		videoFileName = pstData1[0];
+	   	videoFPS = capture->get(CV_CAP_PROP_FPS);
+	    frames = capture->get(CV_CAP_PROP_FRAME_COUNT);
+	    
+	    if(noOfarguments!=1)
+	    {
+	    	if(int(CT) >= int(videoDuration))
+	    	{
+			    Scierror(999,"Current Time should be less than Video Duration\n");
+		        return 0;	    
+        	}
+        	capture->set(CV_CAP_PROP_POS_MSEC, CT);
+	    }
+
+	    videoObjectSt = true;
+	    videoCurrentTime = capture->get(CV_CAP_PROP_POS_MSEC);
+	    videoDuration = (1000/double(videoFPS))*double(frames);
+	    width = capture->get(CV_CAP_PROP_FRAME_WIDTH);
+	    height = capture->get(CV_CAP_PROP_FRAME_HEIGHT);
+    	realpath(pstData1[0], full_path);
+
+	    createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, pstData1[0]);
+	    createScalarDouble(pvApiCtx,nbInputArgument(pvApiCtx) + 2, videoDuration);
+	    createScalarDouble(pvApiCtx,nbInputArgument(pvApiCtx) + 3, videoFPS);
+	    createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx)+4, videoCurrentTime);
+	    createScalarDouble(pvApiCtx,nbInputArgument(pvApiCtx) + 5, frames);
+	    createScalarDouble(pvApiCtx,nbInputArgument(pvApiCtx) + 6, width);
+	    createScalarDouble(pvApiCtx,nbInputArgument(pvApiCtx) + 7, height);
+	    createSingleString(pvApiCtx, nbInputArgument(pvApiCtx)+8, full_path);
+
+	    for(int i=0;i<=8;i++)
+	    {
+ 			AssignOutputVariable(pvApiCtx, i) = nbInputArgument(pvApiCtx) + i;
+ 		}
+    
+	    ReturnArguments(pvApiCtx);
+	    return 0;
+	}
+
+	int has_frame(char *fname, unsigned long fname_len)
+	{
+	    SciErr sciErr;
+
+		if(videoFileName==NULL)
+		{
+	        Scierror(999,"No video has been read yet.\n");
+	        return 0;
+		}
+
+	    int *piAddr = NULL;
+	    int *piLen = NULL;
+	    int iRows, iCols = 0;
+	    char ** pstData = NULL;
+
+	    CheckInputArgument(pvApiCtx,0,0);
+	    CheckOutputArgument(pvApiCtx,0,1);
+
+	    if(videoObjectSt == false)
+	    {
+	    	Scierror(999,"Invalid Video File. You need to read the video using VideoReader.\n");
+	        return 0;
+	    }
+	    
+		if(videoCurrentTime>videoDuration)
+			createScalarBoolean(pvApiCtx,nbInputArgument(pvApiCtx) + 1, false);
+		else if(int(videoCurrentTime) == int(videoDuration))
+			createScalarBoolean(pvApiCtx,nbInputArgument(pvApiCtx) + 1, false);
+		else
+			createScalarBoolean(pvApiCtx,nbInputArgument(pvApiCtx) + 1, true);
+
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		
+		return 0;
+	}
+
+	int read_frame(char *fname, unsigned long fname_len)
+	{
+		SciErr sciErr;
+
+		if(videoFileName==NULL)
+		{
+	        Scierror(999,"No video has been read yet.\n");
+	        return 0;
+		}
+
+		if(int(videoCurrentTime)>=int(videoDuration))
+		{
+	    	Scierror(999,"No more frames left to be read\n");
+	        return 0;
+		}
+		//sciprint("Current Time of the Video is : %f\n", videoCurrentTime);
+	    
+	    int *piAddr = NULL;
+	    int *piLen = NULL;
+	    int iRows, iCols = 0;
+	    char ** pstData = NULL;
+	    int *singleFrameList = NULL;
+ 	    unsigned char *red = NULL;
+	    unsigned char *green = NULL;
+	    unsigned char *blue = NULL;	
+
+	    CheckInputArgument(pvApiCtx,0,0);
+	    CheckOutputArgument(pvApiCtx,0,1);
+
+	    if(videoObjectSt == false)
+	    {
+	    	Scierror(999,"Invalid Video File. You need to read the video using VideoReader.\n");
+	        return 0;
+	    }
+
+//--------------------------------------- Processing Frame at the particular frame -----------------------------------
+
+	    Mat frame;
+	    capture->set(CV_CAP_PROP_POS_MSEC, videoCurrentTime);
+		if(!capture->read(frame))
+		{
+			Scierror(999, "Can't read Frame");
+			return 0;	
+		}
+//--------------------------------------------------------------------------------------------------------------------
+
+	    if(frame.channels()==1)
+	    {
+
+	 		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &singleFrameList);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+			red = (unsigned char *)malloc(sizeof(unsigned char)*frame.rows*frame.cols);
+
+	    	for(int k=0;k<frame.rows;k++)
+                for(int p=0;p<frame.cols;p++)
+                    red[k+frame.rows*p]=frame.at<uchar>(k, p);
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, singleFrameList, 1, frame.rows, frame.cols, red);
+	    	if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}		                
+	
+			free(red);
+		}
+		else
+		{
+
+	    	sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, &singleFrameList);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+			red = (unsigned char *)malloc(sizeof(unsigned char)*frame.rows*frame.cols);
+            green = (unsigned char *)malloc(sizeof(unsigned char)*frame.rows*frame.cols);
+            blue = (unsigned char *)malloc(sizeof(unsigned char)*frame.rows*frame.cols);
+
+		    for(int k=0;k<frame.rows;k++)
+		    {
+                for(int p=0;p<frame.cols;p++)
+                {
+                    Vec3b intensity = frame.at<Vec3b>(k, p);
+                    red[k+frame.rows*p]=intensity.val[2];
+                    green[k+frame.rows*p]=intensity.val[1];
+                    blue[k+frame.rows*p]=intensity.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, singleFrameList, 1, frame.rows, frame.cols, red);
+	    	if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+    		sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, singleFrameList, 2, frame.rows, frame.cols, green);
+	    	if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}	    			
+			sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, singleFrameList, 3, frame.rows, frame.cols, blue);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+					free(red);
+					free(green);
+					free(blue);
+		}
+
+		videoCurrentTime+=(1000/double(videoFPS));
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;	
+
+	    ReturnArguments(pvApiCtx);
+		
+		return 0;
+	}
+}
+
+
+
diff --git a/sci_gateway1/cpp/opencv_arrowedline.cpp b/sci_gateway1/cpp/opencv_arrowedline.cpp
new file mode 100644
index 0000000..0e1643a
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_arrowedline.cpp
@@ -0,0 +1,221 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   return_image = arrowedline(image , x1 , y1 , x2,y2,r_value,g_value,b_value,thickness,linetype,shift,tiplength);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_arrowedline(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10  = NULL;
+    int *piAddr11 = NULL;
+    int *piAddr12 = NULL;
+    int i,j,k;
+    double thickness=1 , linetype=8,shift =0 ,tiplength=0.1;
+    double x1,y1,x2,y2,r_value,g_value,b_value;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 8, 12);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+    
+    //for value of x coordinate of first point
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2 ,&x1);
+    if(intErr)
+          return intErr;
+   
+    //for value of y coordinate of first point
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&y1);
+   if(intErr)
+          return intErr;
+
+    //for value of x coordinate of second point
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4 ,&x2);
+    if(intErr)
+        return intErr;
+
+    ///for value of y coordinate of second point
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&y2);
+    if(intErr)
+          return intErr;
+ 
+      //for value of R value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr) 
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6,&r_value);
+    if(intErr)
+          return intErr;
+
+    // for G value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7,&g_value);
+   if(intErr)
+          return intErr;
+
+ // for B value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8,&b_value);
+   if(intErr)
+          return intErr;
+
+    // for thickness of circle  default: 1
+    sciErr = getVarAddressFromPosition(pvApiCtx,9,&piAddr9);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr9 ,&thickness);
+    if(intErr)
+        return intErr;
+      
+      //for line type of circle default: 8 
+    sciErr = getVarAddressFromPosition(pvApiCtx,10,&piAddr10);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+  
+    intErr = getScalarDouble(pvApiCtx, piAddr10,&linetype);
+     if(intErr)
+        return intErr;
+
+    // for shift in line defulat : 0
+     sciErr = getVarAddressFromPosition(pvApiCtx,11,&piAddr11);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Syntax: sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
+    intErr = getScalarDouble(pvApiCtx, piAddr11 ,&shift);
+     if(intErr)
+        return intErr;
+   
+    // for tiplength of arrow  default : 0.1
+     sciErr = getVarAddressFromPosition(pvApiCtx,12,&piAddr12);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Syntax: sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
+    intErr = getScalarDouble(pvApiCtx, piAddr12,&tiplength);
+    if(intErr)
+        return intErr;
+    //temporary pt variable, to use in function as centre
+    Point pt1(x1,y1);
+    Point pt2(x2,y2);
+    
+ 
+    /// checking the parmeters for correct values   
+    if( r_value <0 || r_value >255)
+     {
+          r_value=0;
+          sciprint(" r value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+     if( g_value <0 || g_value >255)
+     {
+          g_value=0;
+          sciprint(" g value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if( b_value <0 || b_value >255)
+     {
+          b_value=0;
+          sciprint(" b value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+      if ((linetype!=0) && (linetype!=4)&& (linetype!=8))
+    {
+             linetype=8;
+             sciprint("Only 0/4/8 allowed , using 8 instead");
+     }   
+   //calling the opencv function   
+    arrowedLine( src, pt1, pt2, Scalar(b_value,g_value,r_value), thickness, linetype, shift, tiplength);
+     
+    string tempstring = type2str(src.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,src,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
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;
+  }
+}
diff --git a/sci_gateway1/cpp/opencv_bbox2points.cpp b/sci_gateway1/cpp/opencv_bbox2points.cpp
new file mode 100644
index 0000000..975fc00
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_bbox2points.cpp
@@ -0,0 +1,117 @@
+/***************************************************
+Author : Tanmay Chaudhari
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <bits/stdc++.h>
+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"
+ //   #include "../common.cpp"
+
+int opencv_bbox2points()
+{
+	//Error management variable
+	SciErr sciErr;
+	
+	//Variable declaration
+	int i;
+	int iComplex = 0;
+	int iType = 0;
+	int iRows = 0;
+	int iCols = 0;
+	int *piAddr = NULL;
+	double *pdblReal = NULL;
+	double *points;
+
+	//Check input output arguments
+	checkInputArgument(pvApiCtx, 1, 1);
+	checkOutputArgument(pvApiCtx, 1, 1);
+
+	//Get variable address of the first input arguent
+	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+	if(sciErr.iErr)
+	{		
+		printError(&sciErr, 0);
+		return 0;
+	}
+
+	//Check type
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}
+	
+	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
+	if(sciErr.iErr || iCols != 4 || iRows == 0)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	
+	sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+
+	for( i = 0; i < iRows; i++)					//Rows in box
+	{
+		points = (double*)malloc(sizeof(double) * 8);
+		memset(points, 0, sizeof(points));
+
+		//Upper-left
+		points[0] = pdblReal[i];
+		points[4] = pdblReal[i + iRows];	
+
+		//Upper-right
+		points[1] = pdblReal[i] + pdblReal[i + 2 * iRows];
+		points[5] = pdblReal[i + iRows];
+
+		//Lower-right
+		points[2] = pdblReal[i] + pdblReal[i + 2 * iRows];
+		points[6] = pdblReal[i + iRows] + pdblReal[i+ 3 * iRows];
+
+		//Lower-left
+		points[3] = pdblReal[i];
+		points[7] = pdblReal[i + iRows] + pdblReal[i + 3 * iRows];
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, i + 1, 4, 2, points);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+	}
+
+	//Return output arguments
+	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+	ReturnArguments(pvApiCtx);
+	
+	return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_bboxOverlapRatio.cpp b/sci_gateway1/cpp/opencv_bboxOverlapRatio.cpp
new file mode 100644
index 0000000..e43cb12
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_bboxOverlapRatio.cpp
@@ -0,0 +1,275 @@
+/***************************************************
+Author : Tanmay Chaudhari	
+ ***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+	//    #include "../common.cpp"
+
+	int opencv_bboxOverlapRatio(char *fname, unsigned long fname_len)
+	{	
+		//Error management variable
+		SciErr sciErr;
+
+		//Variable declaration
+		int i, j;
+		int nbInputArguments = 0;
+		int iComplex = 0;
+		int iType = 0;
+		int iRows = 0;
+		int iCols = 0;
+		int rowsOfBboxA = 0;
+		int colsOfBboxA = 0;
+		int rowsOfBboxB = 0;
+		int colsOfBboxB = 0;
+		int unionOrMin = 0;	//if 0 then union else min
+		int *piAddr = NULL;
+		int *piLen = NULL;
+		char **ratioType = NULL;
+		double x1 = 0;
+		double x2 = 0;
+		double y1 = 0;
+		double y2 = 0;
+		double w = 0;
+		double h = 0;
+		double intersectAB = 0;
+		double *overlapRatio = 0;
+		double *bboxA = NULL;
+		double *bboxB = NULL;
+		double *x1BboxA = NULL;
+		double *x2BboxA = NULL;
+		double *y1BboxA = NULL;
+		double *y2BboxA = NULL;
+		double *x1BboxB = NULL;
+		double *x2BboxB = NULL;
+		double *y1BboxB = NULL;
+		double *y2BboxB = NULL;
+		double *areaA = NULL;
+		double *areaB = NULL;
+
+		//Check input output arguments
+		checkInputArgument(pvApiCtx, 2, 3);
+		checkOutputArgument(pvApiCtx, 1, 1);
+
+		//Get number of input arguments
+		nbInputArguments = *getNbInputArgument(pvApiCtx);
+
+		for( i = 1; i <= nbInputArguments; i++)
+		{
+			//Get variable address of the input arguent
+			sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddr);
+			if(sciErr.iErr)
+			{	
+				printError(&sciErr, 0);
+				return 0;
+			}
+
+			if(i != 3)
+			{
+				//Check type
+				sciErr = getVarType(pvApiCtx, piAddr, &iType);
+				if(sciErr.iErr || iType != sci_matrix)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+
+				//Get complexity
+				iComplex = isVarComplex(pvApiCtx, piAddr);
+
+				//Check complexity
+				if(iComplex)
+				{
+					Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+					return 0;
+				}
+
+				if(i == 1)
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfBboxA, &colsOfBboxA, &bboxA);
+				else
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfBboxB, &colsOfBboxB, &bboxB);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+
+				if((i == 1) && ((rowsOfBboxA == 0) || (colsOfBboxA !=4)))
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}	
+
+				if((i == 2) && ((rowsOfBboxB == 0) || (colsOfBboxB != 4)))
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}	
+			}
+			else
+			{
+				//first call to retrieve dimensions
+				sciErr = getMatrixOfString(pvApiCtx, piAddr, &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, piAddr, &iRows, &iCols, piLen, NULL);
+				if(sciErr.iErr || iRows != 1 || iCols != 1)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+
+				ratioType = (char**)malloc(sizeof(char*) * iRows * iCols);
+				for(int i=0;i< iRows * iCols; i++)
+				{
+					ratioType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));	//+1 for NULL character
+				}
+
+				//third call to retrieve data
+				sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, ratioType);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				if(piLen[0] != 5 && piLen[0] != 3)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				if(piLen[0] == 5 && ratioType[0][0] == 'U' && ratioType[0][1] == 'n' && ratioType[0][2] == 'i' && ratioType[0][3] == 'o' && ratioType[0][4] == 'n')
+					unionOrMin = 0;
+				else if(piLen[0] == 3 && ratioType[0][0] == 'M' && ratioType[0][1] == 'i' && ratioType[0][2] == 'n')
+					unionOrMin = 1;
+				else
+				{
+					Scierror(999, "%s: Wrong type for input argument: Union or Min is expected.\n");
+					return 0;
+				}
+				free(piLen);
+				free(ratioType);
+			}
+		}
+
+		x1BboxA = (double*)malloc(sizeof(double) * rowsOfBboxA);
+		x2BboxA = (double*)malloc(sizeof(double) * rowsOfBboxA);
+		y1BboxA = (double*)malloc(sizeof(double) * rowsOfBboxA);
+		y2BboxA = (double*)malloc(sizeof(double) * rowsOfBboxA);
+
+		x1BboxB = (double*)malloc(sizeof(double) * rowsOfBboxB);
+		x2BboxB = (double*)malloc(sizeof(double) * rowsOfBboxB);
+		y1BboxB = (double*)malloc(sizeof(double) * rowsOfBboxB);
+		y2BboxB = (double*)malloc(sizeof(double) * rowsOfBboxB);
+
+		areaA = (double*)malloc(sizeof(double) * rowsOfBboxA);
+		areaB = (double*)malloc(sizeof(double) * rowsOfBboxB);
+
+		overlapRatio = (double*)malloc(sizeof(double) * rowsOfBboxA * rowsOfBboxB);
+
+		for( i = 0; i < rowsOfBboxA; i++)
+		{
+			//Left top corner
+			x1BboxA[i] = bboxA[i];
+			y1BboxA[i] = bboxA[rowsOfBboxA + i];
+
+			//right bottom corner
+			x2BboxA[i] = x1BboxA[i] + bboxA[2 * rowsOfBboxA + i];
+			y2BboxA[i] = y1BboxA[i] + bboxA[3 * rowsOfBboxA + i];
+		}
+
+		for( i = 0; i < rowsOfBboxB; i++)
+		{
+			//Left top corner
+			x1BboxB[i] = bboxB[i];
+			y1BboxB[i] = bboxB[rowsOfBboxB + i];
+
+			//right bottom corner
+			x2BboxB[i] = x1BboxB[i] + bboxB[2 * rowsOfBboxB + i];
+			y2BboxB[i] = y1BboxB[i] + bboxB[3 * rowsOfBboxB + i];
+		}
+
+		//Computing area for each rectangle in bboxA
+		for( i = 0; i < rowsOfBboxA; i++)
+			areaA[i] = bboxA[2 * rowsOfBboxA + i] * bboxA[3 * rowsOfBboxA + i];
+
+		//Computing area for each rectangle in bboxB
+		for( i = 0 ; i < rowsOfBboxB; i++)
+			areaB[i] = bboxB[2 * rowsOfBboxB + i] * bboxB[3 * rowsOfBboxB + i];
+
+		for( i = 0; i < rowsOfBboxA * rowsOfBboxB; i++)
+			overlapRatio[i] = 0;
+
+		for( i = 0; i < rowsOfBboxA; i++)
+		{
+			for( j = 0; j < rowsOfBboxB; j++)
+			{
+				//Computing the corners of the intersect
+				x1 = (x1BboxA[i] > x1BboxB[j])?x1BboxA[i]:x1BboxB[j];
+				y1 = (y1BboxA[i] > y1BboxB[j])?y1BboxA[i]:y1BboxB[j];
+				x2 = (x2BboxA[i] < x2BboxB[j])?x2BboxA[i]:x2BboxB[j];
+				y2 = (y2BboxA[i] < y2BboxB[j])?y2BboxA[i]:y2BboxB[j];
+
+				w = x2 - x1;
+				if(w <= 0)			//Skip if no intersection
+					continue;
+
+				h = y2 - y1;
+				if(h <= 0)			//Skip if no intersection
+					continue;
+
+				intersectAB = w * h;
+
+				if(nbInputArguments == 2)
+					overlapRatio[j * rowsOfBboxA + i] = intersectAB/(areaA[i] + areaB[j] - intersectAB); 
+				else
+				{
+					if(unionOrMin == 0)
+						overlapRatio[j * rowsOfBboxA + i] = intersectAB/(areaA[i] + areaB[j] - intersectAB); 
+					else 
+						overlapRatio[j * rowsOfBboxA + i] = intersectAB/((areaA[i] < areaB[j])?areaA[i]:areaB[j]);
+				}
+			}
+		}
+		
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, rowsOfBboxA, rowsOfBboxB, overlapRatio);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Return Output Argument
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+
+		return 0;
+	}
+	/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_blobAnalysis.cpp b/sci_gateway1/cpp/opencv_blobAnalysis.cpp
new file mode 100644
index 0000000..4b23607
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_blobAnalysis.cpp
@@ -0,0 +1,381 @@
+/********************************************************
+Author : Deepshikha
+[key_value] : blobAnalysis(source_image)
+
+// 1 :image
+Optional arguments :-
+// 2 : filterByArea 
+// 3 : filterByThreshold
+// 4 : filterByCircularity
+// 5 : filterByConvexity
+
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include <iostream>
+
+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"
+  
+  int opencv_blobAnalysis(char *fname, unsigned long fname_len){
+
+    // Error management variable
+    SciErr sciErr;
+    
+    //Variables
+    int i, j;
+    int intErr;
+    int iRows1 = 0;
+    int iCols1 = 0;
+	
+	int iRows = 0;
+    int iCols = 0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    char **pstData = NULL;
+    char *currentArg = NULL;
+    bool *providedArgs = NULL; 
+    
+    double *area = NULL;
+    double *threshold = NULL; 
+    double *circularity = NULL;
+    double *convexity = NULL;
+
+    double *key_value = NULL;
+
+    // checking input argument
+    // 1 : image
+    // 2 : filterByArea 
+    // 3 : filterByThreshold
+    // 4 : filterByCircularity
+    // 5 : filterByConvexity
+    CheckInputArgument(pvApiCtx, 1, 9);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+    // retrieve image 
+    Mat image;
+    retrieveImage(image, 1);
+
+    // For the optional arguments
+    int nbInputArguments = *getNbInputArgument(pvApiCtx);
+    //sciprint("%d\n",nbInputArguments);
+    
+    if((nbInputArguments%2) == 0)
+    {
+    	Scierror(999, "%d:  The number of arguments must be odd\n");
+        return 0;
+    }
+    
+    providedArgs = (bool*) malloc(sizeof(bool) * 4); 
+    memset(providedArgs, 0, 4);
+
+    for(int iter = 2; iter <= nbInputArguments; ++iter)
+    {
+        sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        /// Three calls to getMatrixOfString
+        //First Call
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        // Second call to get length of string
+        piLen = (int*) malloc(sizeof(int) * iRows1 * iCols1); 
+        sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows1,  &iCols1,  piLen,  NULL); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        // third call
+        pstData = (char**) malloc(sizeof(char*) * iRows1 * iCols1); 
+        for(int k = 0; k < iRows1 * iCols1; ++k)
+        {
+            pstData[k] = (char*) malloc(sizeof(char) * piLen[k] + 1); 
+        }
+        
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows1, &iCols1, piLen, pstData); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        currentArg = pstData[0];         
+        
+        // getting filterbyArea
+        if(strcmp(currentArg, "filterByArea") == 0)
+        {
+            if(iter + 1 <= nbInputArguments and !providedArgs[0])
+            {
+                sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0); 
+                    return 0; 
+                }
+                sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows1, &iCols1, &area); 
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0); 
+                    return 0; 
+                }
+                if(iRows1 != 1 or iCols1 != 2)
+                {
+                    Scierror(999, "Incorrect dimension of matrix for argument .\n"); 
+                    return 0; 
+                }
+                providedArgs[0] = 1; 
+            }
+            else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+            {
+                Scierror(999, "Please provide optional arguments only once.\n"); 
+                return 0; 
+            }
+            else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+            {
+                Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                return 0; 
+            }
+        }
+
+            /// filterbyThreshold
+            else if(strcmp(currentArg, "filterByThreshold") == 0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows1, &iCols1, &threshold); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows1 != 1 or iCols1 != 2)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument .\n"); 
+                        return 0; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[1] = 1;
+                }
+                else if(providedArgs[1]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            /// filterbycircularity
+            else if(strcmp(currentArg, "filterByCircularity") == 0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows1, &iCols1, &circularity); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows1 != 1 or iCols1 != 2)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument .\n"); 
+                        return 0; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[2] = 1;
+                }
+                else if(providedArgs[2]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+    }
+
+            /// filterbyConvexity
+            else if(strcmp(currentArg, "filterByConvexity") == 0)
+            {
+                if(iter + 1 <= nbInputArguments and !providedArgs[3])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows1, &iCols1, &convexity); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows1 != 1 or iCols1 != 2)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument .\n"); 
+                        return 0; 
+                    }
+
+                    providedArgs[3] = 1; 
+                }
+                else if(providedArgs[3]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            else
+            {
+                Scierror(9,"Invalid argument passed");
+                return 0;
+            }
+        }   
+    /// End of error check and input get;
+
+    /// params for holding the parameters values;
+    SimpleBlobDetector::Params params;
+    
+    /// if area is provided
+    if(providedArgs[0] == 1){
+        params.filterByArea = true;
+        params.minArea = area[0];
+        params.maxArea = area[1];
+    }
+
+    /// if threshold is provided
+    if(providedArgs[1] == 1){
+        params.minThreshold = threshold[0];
+        params.maxThreshold = threshold[1];
+    }
+
+    /// if Circularity is provided
+    if(providedArgs[2] == 1){
+        params.filterByCircularity = true;
+        params.minCircularity = circularity[0];
+        params.maxCircularity = circularity[1];
+    }
+
+    /// if convexity is provided
+    if(providedArgs[3] == 1){
+        params.filterByConvexity = true;
+        params.minConvexity = convexity[0];
+        params.maxConvexity = convexity[1];
+    }
+
+
+    SimpleBlobDetector detector( params );
+
+    /// to store the keypoints of blobs detected
+    vector<KeyPoint> keyPoints;
+    
+    /// fuction to detect blob in the image
+    detector.detect(image, keyPoints);
+    
+    //sciprint("%d", keyPoints.size());
+
+    key_value = (double*)malloc(sizeof(double) * (int)keyPoints.size() * 2);
+
+    double *size_value = NULL;
+
+    size_value = (double*)malloc(sizeof(double) * (int)keyPoints.size() * 1);
+
+    int total_keypoints = (int)keyPoints.size();
+    
+    vector< KeyPoint >::iterator it;
+    
+    for(it = keyPoints.begin(); it != keyPoints.end(); ++it)
+    {
+      KeyPoint temp = keyPoints[i];
+
+      // x coordinate
+      key_value[i + 0 * total_keypoints] = it->pt.x;
+
+      // y coordinate
+      key_value[i + 1 * total_keypoints] = it->pt.y;
+
+      // size
+      size_value[i + 0 * total_keypoints] = it->size;
+
+      //area
+      //key_value[i + 3 * total_keypoints] = it->Area;
+    }
+
+    sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, &piAddr);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, total_keypoints, 2, key_value);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, total_keypoints, 1, size_value);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_blur.cpp b/sci_gateway1/cpp/opencv_blur.cpp
new file mode 100644
index 0000000..3db34ca
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_blur.cpp
@@ -0,0 +1,134 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+
+
+  int opencv_blur(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    double ksize_width,ksize_height,anchorX,anchorY;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for value of ksize_height
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &ksize_height);
+    if(intErr)
+        return intErr;
+
+    //for value of ksize_width
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&ksize_width);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &anchorX);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &anchorY);
+    if(intErr)
+        return intErr;
+
+    //applying checks on input parameters
+    Mat new_image(image.rows,image.cols,image.type());
+
+    //error checks
+    if(ksize_height<0)
+    {
+        sciprint("Positive Value Required for Height. 1 value was used instead");
+        ksize_height=1;
+    }
+    if(ksize_width<0)
+    {
+        sciprint("Positive Value Required for Width. 1 value was used instead");
+        ksize_width=1;
+    }
+    if(ksize_width != ksize_height)
+    {
+        sciprint("Blurring Kernel Size not equal. Value of ksize_height used for ksize_width as well");
+        ksize_width = ksize_height;
+    }
+    if(anchorX >= ksize_height || anchorY >= ksize_width)
+    {
+        sciprint("Invalid anchor points. Default point (-1,-1) used instead");
+        anchorY=-1;
+        anchorX=-1;
+    }
+
+    //defining temporary size and point type variables to use in the function
+    Size sz(ksize_height,ksize_width);
+    Point pt(anchorX,anchorY);
+
+    //void blur(InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT )
+    blur(image,new_image,sz,pt);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_boundingRect.cpp b/sci_gateway1/cpp/opencv_boundingRect.cpp
new file mode 100644
index 0000000..5bf8707
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_boundingRect.cpp
@@ -0,0 +1,82 @@
+/********************************************************
+    Author: Sukul Bagai
+*********************************************************
+   rectangle_dimensions_arry(height, width, x, y) = boundingRect ( vector<point> )
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_boundingRect(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr1 = NULL;
+    int *piAddrNew = NULL;
+    int i,j,k ;
+    double *points;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+    
+//retreive the points 
+    sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &iRows, &iCols,&points);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }  
+    
+    vector<Point> actualPoints;
+    for(int i=0;i<iRows;i++)
+    {
+      actualPoints.push_back(Point(*(points + i),*(points + iRows + i)));
+    }
+    
+    Rect returnRect;
+    returnRect = boundingRect(actualPoints);
+    
+    double arr[4];
+    arr[0]=returnRect.height;
+    arr[1]=returnRect.width;
+    arr[2]=returnRect.x;
+    arr[3]=returnRect.y;
+    
+  sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 4, arr);
+  if(sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return 0;
+  }
+  
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
diff --git a/sci_gateway1/cpp/opencv_bundleAdjustment.cpp b/sci_gateway1/cpp/opencv_bundleAdjustment.cpp
new file mode 100644
index 0000000..1d54615
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_bundleAdjustment.cpp
@@ -0,0 +1,382 @@
+/********************************************************
+Author: Suraj Prakash
+[xyxrefinedPoints] = bundleAdjustment(3dpoints, imagepoints, visibility, cameramatrix, rotation, translation, distcoeffs);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+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"
+  
+  int opencv_bundleAdjustment(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j;
+
+    int iRows = 0;
+    int iCols = 0;
+    int iRows1 = 0;
+    int iCols1 = 0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddr2 = NULL;
+    int *piChild = NULL;
+    int *piAddrNew = NULL;
+    int iItem = 0;
+    double *pdblReal = NULL;
+ 
+    char **pstData = NULL;
+    char *currentArg = NULL;
+    bool *providedArgs = NULL; 
+
+    double *cameraMatrix = NULL; 
+    double *rotationMatrix = NULL;
+    double *translationMatrix = NULL;
+    double *newCameraMatrix = NULL;
+    double *distCoeffs = NULL;
+
+    /// checking input argument
+
+    CheckInputArgument(pvApiCtx, 7, 7);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+    // cv::LevMarqSparse::bundleAdjust (   vector< Point3d > &     points,
+    //                                     const vector< vector< Point2d > > &     imagePoints,
+    //                                     const vector< vector< input > > &     visibility,
+    //                                     vector< Mat > &     cameraMatrix,
+    //                                     vector< Mat > &     R,
+    //                                     vector< Mat > &     T,
+    //                                     vector< Mat > &     distCoeffs,
+    //                                     const TermCriteria &    criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON),
+    //                                     BundleAdjustCallback    cb = 0,
+    //                                     void *  user_data = 0 
+    //                                 )   
+
+    ///////////          getting the 3d points
+    vector< Point3d > points;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    for(i=0; i<iRows; i++)
+    {
+        points.push_back(Point3d(pdblReal[i + 0 * iRows], pdblReal[i + 1 * iRows], pdblReal[i + 2 * iRows]));
+    }
+    
+    /// getting image points M * N * 2
+
+    double *pstDatax = NULL;
+    double *pstDatay = NULL;
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //retrive the matrix of the x coordinates   
+    sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDatax);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //retrive address of the list
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+    //retrive the matrix of the y coordinates 
+    sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDatay);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    vector< vector< Point2d > > imagePoints;
+
+    imagePoints.resize(iRows);
+
+    for(i=0; i<iRows; ++i){
+        for(j=0; j<iCols; ++j){
+            imagePoints[i].push_back(Point2d(pstDatax[i + iRows * j], pstDatay[i + iRows * j]));
+        }
+    }
+
+
+    /// getting the visibility matrix
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3  , &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    vector< vector < int> > visibility(iRows, vector< int >(iCols, 0));
+
+    for(i=0; i<iRows; ++i){
+        for(j=0; j<iCols; ++j)
+            visibility[i][j] = pdblReal[i + j * iRows];
+    }
+
+
+
+
+    ///  M * 3 * 3 camera matrix
+    vector< Mat > camera;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    sciErr = getListItemNumber(pvApiCtx, piAddr, &iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    for(int item = 0; item<iItem; ++item){
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            
+            //retrive the matrix of the camera values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, item + 1, &iRows, &iCols, &cameraMatrix);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            Mat temp(3, 3, CV_64F);
+
+            for(i=0; i<3; ++i)
+                for(j=0; j<3; ++j)
+                    temp.at<double>(i, j) = cameraMatrix[i + j * 3];
+
+            camera.push_back(temp);
+
+    }
+
+    ///  M * 3 * 3 rotation matrix
+    vector< Mat > rotation;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    sciErr = getListItemNumber(pvApiCtx, piAddr, &iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    for(int item = 0; item<iItem; ++item){
+            sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            
+            //retrive the matrix of the camera values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, item + 1, &iRows, &iCols, &rotationMatrix);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            Mat temp(3, 3, CV_64F);
+
+            for(i=0; i<iRows; ++i)
+                for(j=0; j<iCols; ++j)
+                    temp.at<double>(i, j) = rotationMatrix[i + j * iRows];
+
+            rotation.push_back(temp);
+
+    }
+
+
+    ///  M * 3 * 1 translation matrix
+    vector< Mat > translation;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    sciErr = getListItemNumber(pvApiCtx, piAddr, &iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    for(int item = 0; item<iItem; ++item){
+            sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            
+            //retrive the matrix of the camera values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, item + 1, &iRows, &iCols, &translationMatrix);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            Mat temp(3, 1, CV_64F);
+
+            for(i=0; i<3; ++i)
+                for(j=0; j<1; ++j)
+                    temp.at<double>(i, j) = translationMatrix[i + j * 3];
+
+            translation.push_back(temp);
+
+    }
+
+
+    ///  M * (4, 5, 8) * 1 distCoefficients matrix
+    vector< Mat > distCoefficients;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    sciErr = getListItemNumber(pvApiCtx, piAddr, &iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    for(int item = 0; item<iItem; ++item){
+            sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            
+            //retrive the matrix of the camera values   
+            sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, item + 1, &iRows, &iCols, &distCoeffs);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            Mat temp(iRows, iCols, CV_64F);
+
+            for(i=0; i<iRows; ++i)
+                for(j=0; j<iCols; ++j)
+                    temp.at<double>(i, j) = distCoeffs[i + j * iRows];
+
+            distCoefficients.push_back(temp);
+
+    }
+
+    // cv::LevMarqSparse::bundleAdjust (   vector< Point3d > &     points,
+    //                                     const vector< vector< Point2d > > &     imagePoints,
+    //                                     const vector< vector< input > > &     visibility,
+    //                                     vector< Mat > &     cameraMatrix,
+    //                                     vector< Mat > &     R,
+    //                                     vector< Mat > &     T,
+    //                                     vector< Mat > &     distCoeffs,
+    //                                     const TermCriteria &    criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON),
+    //                                     BundleAdjustCallback    cb = 0,
+    //                                     void *  user_data = 0 
+    //                                 )   
+
+    /// TermCriteria
+    
+    TermCriteria criteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 30, DBL_EPSILON);
+
+    LevMarqSparse   lms;
+    lms.bundleAdjust(points, imagePoints, visibility, camera, rotation, translation, distCoefficients, criteria);
+
+
+    double *ans = NULL;
+
+    ans = (double*)malloc(sizeof(double) * points.size() * 3);
+
+    for(i = 0; i < points.size(); ++i){
+        ans[i + 0 * points.size()] = points[i].x;
+        ans[i + 1 * points.size()] = points[i].y;
+        ans[i + 2 * points.size()] = points[i].z;
+    }
+
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, points.size(), 3 , ans);
+    if(sciErr.iErr){
+      printError(&sciErr, 0);
+      return 0;
+    }
+    
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_cameraMatrix.cpp b/sci_gateway1/cpp/opencv_cameraMatrix.cpp
new file mode 100644
index 0000000..3110017
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_cameraMatrix.cpp
@@ -0,0 +1,186 @@
+/***************************************************
+Author : Tanmay Chaudhari
+ **************************************************/
+
+#include <numeric>
+#include <iostream>
+using namespace std;
+extern "C"
+{
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "BOOL.h"
+#include <localization.h>
+#include "sciprint.h"
+
+	int opencv_cameraMatrix(char *fname, unsigned long fname_len)
+	{
+		//Error management variable
+		SciErr sciErr;
+
+		//Variable declaration
+		int iComplex = 0;
+		int iType = 0;
+		int iRows = 0;
+		int iCols = 0;
+		int *piAddr = NULL;
+		double *instrinsicMatrix = NULL;
+		double *rotationMatrix = NULL;
+		double *translationVector = NULL;
+		double *camMatrix = NULL;
+		double *tempMatrix = NULL;
+
+		//Check input output arguments
+		checkInputArgument(pvApiCtx, 3, 3);
+		checkOutputArgument(pvApiCtx, 1, 1);
+
+		//Get variable address of the first input argument
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &instrinsicMatrix);
+		if(sciErr.iErr || iCols != 3 || iRows != 3)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get variable address of the second input argument
+		sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &rotationMatrix);
+		if(sciErr.iErr || iCols != 3 || iRows != 3)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get variable address of the first third argument
+		sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &translationVector);
+		if(sciErr.iErr || iCols != 3 || iRows != 1)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		tempMatrix = (double*)malloc(sizeof(double) * 12);
+		
+		for(int i = 0; i < 4; i++)
+		{
+			for(int j = 0; j < 3; j++)
+			{
+				if(i == 3)	
+					tempMatrix[j * 4 + i] = translationVector[j];
+				else
+					tempMatrix[j * 4 + i] = rotationMatrix[j * 3 + i];
+			}
+		}
+
+		camMatrix = (double*)malloc(sizeof(double) * 12);
+		for(int i = 0; i < 12; i++)
+			camMatrix[i] = 0;
+
+		for(int i = 0; i < 4; i++)
+		{
+			for(int j = 0; j < 3; j++)
+			{
+				for(int k = 0; k < 3; k++)
+				{
+					camMatrix[j * 4 + i] += (tempMatrix[k * 4 + i] * instrinsicMatrix[j * 3 + k]);
+				}
+			}
+		}
+
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 4, 3, camMatrix);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Return output arguments
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
+
+
+
diff --git a/sci_gateway1/cpp/opencv_canny.cpp b/sci_gateway1/cpp/opencv_canny.cpp
new file mode 100644
index 0000000..010d634
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_canny.cpp
@@ -0,0 +1,121 @@
+/********************************************************
+Authors: Sukul Bagai, Abhilasha Sancheti, Shubheksha Jalan 
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  int opencv_canny(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k;
+    double aperture, threshold1, threshold2, gradient;
+    bool L2gradient = false;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+
+    Mat image;
+    retrieveImage(image, 1); 
+    cvtColor( image, image, CV_BGR2GRAY );
+
+    //for value of threshold1
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   intErr = getScalarDouble(pvApiCtx, piAddr2, &threshold1);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+
+    //for value of threshold2
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   intErr = getScalarDouble(pvApiCtx, piAddr3, &threshold2);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+
+    //for value of aperture
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &aperture);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+
+    //for value of gradient as an integer and convert to bool accordingly
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &gradient);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    if ( gradient == 1){
+        L2gradient = true;
+    }
+    Mat new_image;
+    Canny(image, new_image, threshold1, threshold2, aperture, L2gradient);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_circle.cpp b/sci_gateway1/cpp/opencv_circle.cpp
new file mode 100644
index 0000000..928c251
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_circle.cpp
@@ -0,0 +1,203 @@
+/********************************************************
+    Author: Abhilasha Sancheti 
+*********************************************************
+   return_image = circle(input_image , x_coordinate_of_centre , y_coordinate_centre , radius, r_value,g_value,b_value,thickness,linetype,shift);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_circle(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10  = NULL;
+    int i,j,k;
+    double thickness=1 , linetype=8,shift =0 ,centre_x ,centre_y,radius,r_value,g_value,b_value;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 10, 10);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+   
+    //for value of x coordinate of centre
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&centre_x);
+    if(intErr)
+        return intErr;
+   
+
+    //for value of y coordinate of centre
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&centre_y);
+     if(intErr)
+        return intErr;
+
+    //for value of radius
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&radius);
+   if(intErr)
+        return intErr;
+
+    //for value of R value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&r_value);
+    if(intErr)
+        return intErr;
+
+      //for value of G value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6 ,&g_value);
+     if(intErr)
+        return intErr;
+
+    // for B value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7,&b_value);
+     if(intErr)
+        return intErr;
+
+    // for thickness of circle  default: 1
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8,&thickness);
+    if(intErr)
+        return intErr;
+
+      //for line type of circle default: 8 
+    sciErr = getVarAddressFromPosition(pvApiCtx,9,&piAddr9);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+  
+    intErr = getScalarDouble(pvApiCtx, piAddr9,&linetype);
+    if(intErr)
+        return intErr;
+
+ // for shift in circle defulat : 0
+     sciErr = getVarAddressFromPosition(pvApiCtx,10,&piAddr10);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Syntax: sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
+    intErr = getScalarDouble(pvApiCtx, piAddr10,&shift);
+    if(intErr)
+        return intErr;
+   
+    // checking radius parameter 
+    if (radius <0)
+    {
+        radius=3;
+        sciprint("Radius should be positive , 3 value was used instead\n");
+    }
+    // checking the parmeters for correct values   
+    if( r_value <0 || r_value >255)
+     {
+          r_value=0;
+          sciprint(" r value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+     if( g_value <0 || g_value >255)
+     {
+          g_value=0;
+          sciprint("  g value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if( b_value <0 || b_value >255)
+     {
+          b_value=0;
+          sciprint(" b value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if ((linetype!=0) && (linetype!=4)&& (linetype!=8))
+    {
+             linetype=8;
+             sciprint("Only 0/4/8 allowed , using 8 instead\n");
+     }
+    //temporary pt variable, to use in function as centre
+    Point pt(centre_x,centre_y);
+      /// Draw the circles detected
+   
+    circle( src, pt, radius, Scalar(r_value,g_value,b_value), thickness, linetype, shift);
+     
+//// sending the image
+    string tempstring = type2str(src.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,src,1);
+    free(checker);
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_clipline.cpp b/sci_gateway1/cpp/opencv_clipline.cpp
new file mode 100644
index 0000000..2e13412
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_clipline.cpp
@@ -0,0 +1,149 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   return_image = clipline( width, height, x1 , y1 , x2,y2 )
+********************************************************/
+ 
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_clipline(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr1 = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int i,j,k;
+    double x1,y1,x2,y2,width,height;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    //for width of the rectangle    
+     sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr1);
+    if (sciErr.iErr) 
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr1 ,&width);
+    if(intErr)
+      return intErr;
+
+    // for height of the rectangle
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&height);
+    if(intErr)
+      return intErr;
+  
+    //for value of x coordinate of first point
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &x1);
+    if(intErr)
+        return intErr;
+
+    //for value of y coordinate of first point
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&y1);
+    if(intErr)
+      return intErr;
+
+    //for value of x coordinate of second point
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5,&x2);
+    if(intErr)
+      return intErr;
+
+    ///for value of y coordinate of second point
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6 ,&y2);
+     if(intErr)
+      return intErr;
+    
+
+    if(height<0)
+    {
+        sciprint("Positive Value Required for Height. 1 value was used instead");
+        height=1;
+    }
+    if(width<0)
+    {
+        sciprint("Positive Value Required for Width. 1 value was used instead");
+        width=1;
+    }  
+    //temporary pt1 variable, to use in function as first line point
+    Point pt1(x1,y1);
+    //temporary pt2 variable, to use in function as second line point
+    Point pt2(x2,y2);
+    // image size
+    Size sz(width,height);
+    Rect  r(0,0,width,height);
+   //// calling open cv clipLine function       
+   
+    bool ans = clipLine( sz , pt1, pt2);
+    int actualans=(int)ans;
+     
+  // returning the result to the scilab environment
+   // Syntax: SciErr createMatrixOfBoolean(void* _pvCtx, int _iVar, int _iRows, int _iCols, const int* _piBool)
+  intErr= createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, actualans);
+    if(intErr)
+       return intErr;
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_convexhull.cpp b/sci_gateway1/cpp/opencv_convexhull.cpp
new file mode 100644
index 0000000..934fa20
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_convexhull.cpp
@@ -0,0 +1,140 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   hull = convexhull ( contour(vector<point>), clockwise(1/0) , returnpoints(1/0) )
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_convexhull(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr1 = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    double *pstData = NULL;
+    int i,j,k ;
+    double clkwise;
+    double returnpoints;
+ 
+   
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    
+//retreive the contour parameter 
+      sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &iRows, &iCols,&pstData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    } 
+    //cout<<*(pstData + 0*2 + 0)<<" "<<*(pstData + 0*2 + 1)<<endl;
+     //cout<<*(pstData + 1*2 + 2)<<" "<<*(pstData + 1*2 + 3);
+///// store values in a contour
+    int rows = iRows;
+    vector<Point> cont1;
+    for ( i = 0 ; i < iRows ; i++)
+    {
+        Point pt(*(pstData + 0*iRows + i),*(pstData + 1*iRows + i));
+        cont1.push_back(pt);
+    }
+     sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2 ,&clkwise);
+    if(intErr)
+      return intErr;
+     
+    
+    
+//// to retreive the value of returnpoint 
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&returnpoints);
+    if(intErr)
+       return intErr;
+
+   
+    bool clkWise, returnPoint;
+/// setting clkwise parameter of function
+    if ( clkwise ==1)
+      clkWise = true;
+    else if (clkwise == 0)
+     clkWise = false;
+    else
+     {
+        clkWise = false;
+        sciprint("only 0/1 acceptable , taking 0 instead");
+      }
+///// setting returnpoint parameter of function
+     if ( returnpoints ==1)
+      returnPoint = true;
+    else if (returnpoints == 0)
+     returnPoint = false;
+    else
+     {
+        returnPoint = true;
+        sciprint("only 0/1 acceptable , taking 1 instead");
+      }
+    
+       vector<Point> hull;
+       convexHull(Mat(cont1), hull , clkWise , returnPoint);
+	  int row = hull.size();
+	  double *cor = (double *)malloc(row*2*sizeof(double));
+	  for (int i=0;i<row;i++)
+	  {
+	      *(cor + i*2 +0)=hull[i].x;
+      cout<<hull[i].x<<" "<<hull[i].y;
+	      *(cor + i*2 +1)=hull[i].y;
+	  }
+    
+  sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, row, 2, cor);
+  if(sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return 0;
+  }
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
diff --git a/sci_gateway1/cpp/opencv_convolver.cpp b/sci_gateway1/cpp/opencv_convolver.cpp
new file mode 100644
index 0000000..8ffc67b
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_convolver.cpp
@@ -0,0 +1,243 @@
+/******************************************************************************************
+*Author : Kevin George
+*
+*-> To execute, Image = convolver(I1, size, values,scalar)
+*   where 'I1' is image to be convoluted,
+*   where 'size' is size of kernel i.e size x size gives total no. of values in kernel,
+*   where 'values' contains the values of the kernel 
+*   where 'scalar' is a float value
+*
+*******************************************************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include <iostream>
+#include <math.h>
+#include <vector>
+
+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"
+    // # include "../common.cpp"
+
+    int opencv_convolver(char *fname, unsigned long fname_len)
+    {
+    	//-> Error Management variables
+    	SciErr sciErr;
+    	int intErr=0;
+
+        //-> Mat containers for images
+        Mat image_1;
+        Mat image_2;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+
+        //-> Local Variables
+        double *values1 = NULL;
+        float *values2 =NULL;
+        double size;
+        double scalar;
+        int iRows = 0; 
+        int iCols = 0;
+        int *outList = NULL;
+        unsigned char *red = NULL;
+        unsigned char *green = NULL;
+        unsigned char *blue = NULL;
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        CheckInputArgument(pvApiCtx, 1, 5);                     //Check on Number of Input Arguments
+        CheckOutputArgument(pvApiCtx, 1, 5);                    //Check on Number of Output Arguments
+
+    	//-> Read Image
+        retrieveImage( image_1, 1);
+        //retrieveImage(image_2, 2);
+
+        //-> Count number of input arguments
+        //num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        //-> Based on number of input arguments
+
+//*****************************************************  Actual Processing  *************************************************************
+
+     	//-> Taking in size of kernel
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+                    
+        //intErr = getScalarInteger32(pvApiCtx, piAddr, &size);
+        intErr = getScalarDouble(pvApiCtx, piAddr, &size); 
+        if(intErr)
+        {
+             return intErr; 
+        }
+
+        if( size > 5)
+        {
+              Scierror(999," Invalid Value size. Please enter a non negative Double value\\n");
+              return 0;
+        }   
+
+        //-> Taking the kernel values
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &values1);
+        //sciErr =  getMatrixOfInteger32(pvApiCtx, piAddr, &iRows, &iCols, &values); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows*iCols!=9 && iRows*iCols!=16 && iRows*iCols!=25 )
+        {   
+    	    Scierror(999,"Invalid Argument\n");
+            return 0;
+        }           
+
+       	values2 = (float*)malloc(sizeof(float)*size*size);
+        for(int i=0; i<size*size; i++)
+        {
+            values2[i] = (float)values1[i];
+        }
+
+        
+        //-> Taking scalar values
+        sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        intErr = getScalarDouble(pvApiCtx, piAddr, &scalar); 
+        if(intErr)
+        {
+             return intErr; 
+        }
+
+        if( scalar == 0)
+        {
+              Scierror(999," Invalid scalar value. Please enter a non negative Double value\\n");
+              return 0;
+        }
+
+        //float kdata[] = {1, 4, 6, -1, 3, 5, -1, -2, 2};
+  		Mat kernel(size,size,CV_32F, values2);
+
+  	    Mat kernel2 = kernel/ (float)(scalar);
+
+        Point anchor;
+        double delta;
+        int ddepth;
+
+        anchor = Point( -1, -1 );
+        delta = 0;
+        ddepth = -1;
+
+        //filter2D(image_1, image_2, CV_32F, kernel);
+        filter2D(image_1, image_2, ddepth,kernel2,anchor,delta, BORDER_DEFAULT);
+  	    
+  	    //imshow("Convoluted Image",image_2);
+  	    //waitKey(0);
+
+        if( image_2.channels() == 1)
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &outList);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            red = (unsigned char *)malloc(sizeof(unsigned char)*image_2.rows*image_2.cols);
+
+            for(int k=0;k<image_2.rows;k++)
+                for(int p=0;p<image_2.cols;p++)
+                    red[k+image_2.rows*p]=image_2.at<uchar>(k, p);
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, image_2.rows, image_2.cols, red);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }                       
+            free(red);
+        }
+
+        else
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, &outList);
+            if(sciErr.iErr)
+            {
+                    printError(&sciErr, 0);
+                    return 0;
+            }
+
+            red = (unsigned char *)malloc(sizeof(unsigned char)*image_2.rows*image_2.cols);
+            green = (unsigned char *)malloc(sizeof(unsigned char)*image_2.rows*image_2.cols);
+            blue = (unsigned char *)malloc(sizeof(unsigned char)*image_2.rows*image_2.cols);
+
+            for(int k=0;k<image_2.rows;k++)
+            {
+                for(int p=0;p<image_2.cols;p++)
+                {
+                    Vec3b intensity = image_2.at<Vec3b>(k, p);
+                    red[k+image_2.rows*p]=intensity.val[2];
+                    green[k+image_2.rows*p]=intensity.val[1];
+                    blue[k+image_2.rows*p]=intensity.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, image_2.rows, image_2.cols, red);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 2, image_2.rows, image_2.cols, green);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }                   
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 3, image_2.rows, image_2.cols, blue);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                free(red);
+                free(green);
+                free(blue); 
+
+        }
+
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_copymakeborder.cpp b/sci_gateway1/cpp/opencv_copymakeborder.cpp
new file mode 100644
index 0000000..51175fb
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_copymakeborder.cpp
@@ -0,0 +1,195 @@
+/********************************************************
+    Author: Shubheksha Jalan
+*********************************************************
+  void copyMakeBorder(InputArray image, int top, int bottom, int left, int right, int borderType, const Scalar& value=Scalar() )
+********************************************************/
+// for BORDER_CONSTANT, enter a 4 element array as Scalar. For any other border type, pass 0.
+
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_copymakeborder(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    int i,j,k;
+    char **borderType;
+    double top, bottom, right, left;
+    double *value = NULL;
+     //checking input argument
+    CheckInputArgument(pvApiCtx, 6, 7);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for top
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &top);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for bottom
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr3, &bottom);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+     //for left
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr4, &left);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+     //for bottom
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr5, &right);
+    if(intErr)
+    {
+        return intErr;
+    }
+
+
+      sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr6, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr6, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr6, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for array of Scalar object
+     sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr7, &iRows, &iCols ,&value);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+
+    Mat new_image(Size(image.cols+left+right, image.rows+top+bottom), image.type());  
+
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0  && iCols == 4 )
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_CONSTANT,  Scalar(value[0], value[1], value[2], value[3]));
+    else if(strcmp(borderType[0], "BORDER_CONSTANT") == 0 && iCols == 3)
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_CONSTANT, Scalar(value[0], value[1], value[2]));
+    else if(strcmp(borderType[0], "BORDER_DEFAULT") == 0)
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_DEFAULT);
+    else if(strcmp(borderType[0], "BORDER_REPLICATE") == 0)
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_REPLICATE);
+    else if(strcmp(borderType[0], "BORDER_REFLECT") == 0)
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_REFLECT);
+    else if(strcmp(borderType[0], "BORDER_REFLECT_101") == 0)
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_REFLECT_101);
+    else if(strcmp(borderType[0], "BORDER_WRAP") == 0)
+          copyMakeBorder(image, new_image, top, bottom, left, right, BORDER_WRAP);
+
+    // namedWindow ("window", 1);
+    // imshow("window", new_image);
+    //  waitKey(0);
+    //  destroyWindow("window");
+
+free(borderType);
+
+string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_corner.cpp b/sci_gateway1/cpp/opencv_corner.cpp
new file mode 100644
index 0000000..96c1f4c
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_corner.cpp
@@ -0,0 +1,469 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <math.h>
+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"
+    
+    /*Calling syntax: corner(I) or corner(I, Name, Value)   
+       which uses additional options specified by one or more Name, Value pair arguments.             
+       Arguments Allowed: MinQuality, FilterSize, ROI, SensitivityFactor
+       MinQuality        : The minimum accepted quality of corners represents a fraction of the
+                           maximum corner metric value in the image. Larger values can be used 
+                           to remove erroneous corners.
+       FilterSize        : Gaussian filter dimension
+       ROI               : Rectangular region for corner detection
+       SensitivityFactor : A scalar value, K, where 0 < K < 0.25, specifying the sensitivity 
+                           factor used in the Harris detection algorithm.                    
+       Method            : Whether to use 'Harris' or 'MinimumEigenValue' technique                       */
+
+    int opencv_corner(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr; 
+        int intErr; 
+        
+        //------Local variables------//        
+        int *location = NULL; 
+        double *metric = NULL; 
+        int *piAddr = NULL;       
+        int *piLen = NULL; 
+        int nbInputArguments; 
+        char **pstData = NULL; 
+        char *currentArg = NULL; 
+        bool *providedArgs = NULL; 
+        double *matrixOfRoi;  // ROI[xStart, yStart, width, height]
+        int iRows, iCols; 
+        Mat sourceImage, dst, dstThresholded, ucharDstThresholded, extended; 
+        vector<vector<Point> > contours; 
+        char *method;
+        double filterSize = 5, minQuality = 0.01, sensitivityFactor = 0.04, blockSize = 2, maxDst, localMax; 
+        bool *included = NULL; 
+        int pointCount = 0, localMaxPos; 
+        double tempForSwapping;
+        int coordinateMin, coordinatePos;
+        
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 1, 11); 
+        CheckOutputArgument(pvApiCtx, 1, 3); 
+        
+        //------Get input arguments------//
+        retrieveImage(sourceImage, 1); 
+        if(sourceImage.channels() != 1)
+        {
+            Scierror(999, "The input image is not a grayscale image."); 
+            return 0; 
+        }
+        matrixOfRoi = (double*) malloc(sizeof(double) * 4); 
+        providedArgs = (bool*) malloc(sizeof(bool) * 5); 
+        memset(providedArgs, 0, 5); 
+        method = "Harris";
+        matrixOfRoi[0] = 0; 
+        matrixOfRoi[1] = 0; 
+        matrixOfRoi[2] = sourceImage.cols; 
+        matrixOfRoi[3] = sourceImage.rows; 
+        nbInputArguments = *getNbInputArgument(pvApiCtx); 
+        
+        // The following loop is for checking if optional arguments have been provided
+        for(int iter=2; iter <= nbInputArguments; iter++)
+        {
+            // Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            // Extracting name of next argument takes three calls to getMatrixOfString
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+            
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+            
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            currentArg = pstData[0]; 
+            // providedArgs[] makes sure that no optional argument is provided more than once
+            if(strcmp(currentArg, "MinQuality")==0)
+            {
+                if(iter+1<=nbInputArguments && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &minQuality); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    // Checking if values are in proper range. Same for all optional arguments
+                    if(minQuality < 0 || minQuality > 1)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible range is [0, 1].\n", currentArg); 
+                        return 0; 
+                    }
+                    providedArgs[0] = 1; 
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "FilterSize")==0)
+            {
+                if(iter+1 <= nbInputArguments  && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &filterSize); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    providedArgs[1] = 1; 
+                    if(filterSize!=1 && filterSize!=3 && filterSize!=5 && filterSize!=7)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are {1, 3, 5, 7}.\n", currentArg); 
+                        return 0; 
+                    }
+                }
+                else if(providedArgs[1])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "ROI")==0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+                    {
+                        Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &matrixOfRoi); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows!=1 || iCols!=4)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument ROI.\n"); 
+                        return 0; 
+                    }
+                    providedArgs[2] = 1; 
+                    if(matrixOfRoi[0] < 0 || matrixOfRoi[0] > sourceImage.cols || matrixOfRoi[1] < 0 ||
+                        matrixOfRoi[1] > sourceImage.rows || matrixOfRoi[2] < 0 || matrixOfRoi[0] + matrixOfRoi[2] > sourceImage.cols
+                        || matrixOfRoi[3] < 0 || matrixOfRoi[1] + matrixOfRoi[3] > sourceImage.rows)
+                    {
+                        Scierror(999, "Error: Please provide proper values for \"%s\".\n", currentArg); 
+                        return 0; 
+                    }
+                }
+                else if(providedArgs[2])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "SensitivityFactor")==0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[3])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &sensitivityFactor); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    providedArgs[3] = 1; 
+                    if(sensitivityFactor < 0 || sensitivityFactor > 0.25)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are [0, 0.25].\n", currentArg); 
+                        return 0; 
+                    }
+                }
+                else if(providedArgs[3])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "Method")==0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[4])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+                    
+                    sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+                    for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+                    {
+                        pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+                    }
+                    
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    method = pstData[0];
+                    providedArgs[4] = 1; 
+                    if(strcmp(method, "Harris") !=0 && strcmp(method, "MinimumEigenValue") !=0)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are [\"Harris\" , \"MinimumEigenValue\"].\n", currentArg); 
+                        return 0; 
+                    }
+                }
+                else if(providedArgs[4])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else
+            {
+                Scierror(999, "Error: \"%s\" name for input argument is not valid.\n", currentArg); 
+                return 0; 
+            }
+        }
+        
+        //------Actual processing------//
+        if(strcmp(method, "Harris") == 0)
+        {
+            cornerHarris(sourceImage(Rect(matrixOfRoi[0], matrixOfRoi[1], matrixOfRoi[2], matrixOfRoi[3])), dst, blockSize, filterSize, sensitivityFactor, BORDER_DEFAULT); 
+        }
+        else
+        {
+            cornerMinEigenVal(sourceImage(Rect(matrixOfRoi[0], matrixOfRoi[1], matrixOfRoi[2], matrixOfRoi[3])), dst, blockSize, filterSize, BORDER_DEFAULT);
+        }
+        // Finding the maximum value at a pixel in dst        
+        maxDst = 0; 
+        for(int rowIter=0; rowIter < dst.rows; rowIter++)
+        {
+            for(int colIter=0; colIter < dst.cols; colIter++)
+            {
+                if(dst.at<float>(rowIter, colIter) > maxDst)
+                {
+                    maxDst = dst.at<float>(rowIter, colIter); 
+                }
+            }
+        }
+        
+        /* First, we threshold dst according to the minQuality expected by the user.
+           We then find contours in the thresholded image and check each pixel's value
+           to compute the local maxima. A extended mat is created because contours 
+           having edges on the boundaries of the images are not considered by 
+           findContours                                                                */
+        threshold(dst, dstThresholded, maxDst*minQuality, 255, THRESH_BINARY); 
+        dstThresholded.convertTo(ucharDstThresholded, CV_8UC1); 
+        extended = Mat(dst.rows+2, dst.cols+2, CV_8UC1); 
+        for(int rowIter = 0; rowIter < extended.rows; rowIter++)
+        {
+            for(int colIter = 0; colIter < extended.cols; colIter++)
+            {
+                if(rowIter == 0 || rowIter == extended.rows - 1
+                || colIter == 0 || colIter == extended.cols - 1)
+                {
+                    extended.at<uchar>(rowIter, colIter) = 0; 
+                }
+                else
+                {
+                    extended.at<uchar>(rowIter, colIter) = ucharDstThresholded.at<uchar>(rowIter-1, colIter-1); 
+                }
+            }
+        }
+        
+        findContours(extended, contours, CV_RETR_TREE, CV_CHAIN_APPROX_NONE); 
+        pointCount = contours.size(); 
+        location = (int*) malloc(sizeof(int) * pointCount * 2); 
+        metric = (double*) malloc(sizeof(double)*pointCount); 
+        for(int rowIter = 0; rowIter < contours.size(); rowIter++)
+        {
+            localMax = 0; 
+            localMaxPos = 0; 
+            for(int colIter=0; colIter<contours[rowIter].size(); colIter++)
+            {
+                if(dst.at<float>(contours[rowIter][colIter].y-1, contours[rowIter][colIter].x-1)>localMax)
+                {
+                    localMax = dst.at<float>(contours[rowIter][colIter].y-1, contours[rowIter][colIter].x-1); 
+                    localMaxPos = colIter; 
+                }
+            }
+            if(localMax > maxDst*minQuality)
+            {
+                location[rowIter] = contours[rowIter][localMaxPos].x-1 + matrixOfRoi[0]; 
+                location[pointCount + rowIter] = contours[rowIter][localMaxPos].y-1 + matrixOfRoi[1]; 
+                metric[rowIter] = dst.at<float>(location[pointCount + rowIter], location[rowIter]); 
+            }
+        }
+        
+        // To return coordinates in order
+        for(int iter1 = 0; iter1 < pointCount - 1; iter1++)
+        {
+            coordinateMin = location[iter1];
+            coordinatePos = iter1;
+            for(int iter2 = iter1 + 1; iter2 < pointCount; iter2++)
+            {
+                if(location[iter2] < coordinateMin)
+                {
+                        coordinateMin = location[iter2];
+                        coordinatePos = iter2;
+                }
+                else if(location[iter2] == coordinateMin)
+                {
+                    if(location[pointCount + iter2] < location[pointCount + coordinatePos])
+                    {
+                        coordinateMin = location[iter2];
+                        coordinatePos = iter2;
+                    }
+                }
+            }
+            // Swapping x coordinate
+            tempForSwapping = location[coordinatePos];
+            location[coordinatePos] = location[iter1];
+            location[iter1] = tempForSwapping; 
+            // Swapping y coordinate
+            tempForSwapping = location[pointCount + coordinatePos];
+            location[pointCount + coordinatePos] = location[pointCount + iter1];
+            location[pointCount + iter1] = tempForSwapping; 
+            // Swapping metric
+            tempForSwapping = metric[coordinatePos];
+            metric[coordinatePos] = metric[iter1];
+            metric[iter1] = tempForSwapping; 
+        }
+        
+        //------Create output arguments------//
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+1, pointCount, 2, location); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+2, pointCount, 1, metric); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+3, 1, 1, &pointCount); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1; 
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2; 
+        AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3; 
+        ReturnArguments(pvApiCtx); 
+        return 0; 
+    }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_cornerEigenValsAndVecs.cpp b/sci_gateway1/cpp/opencv_cornerEigenValsAndVecs.cpp
new file mode 100644
index 0000000..205759d
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_cornerEigenValsAndVecs.cpp
@@ -0,0 +1,127 @@
+/********************************************************
+Author: Shubheksha Jalan 
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  
+  int opencv_cornerEigenValsAndVecs(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4 = NULL;
+    int i,j,k;
+    double blockSize, ksize;
+    char **borderType;
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1); 
+    cvtColor(image,image,CV_BGR2GRAY);
+    
+    //for block size
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &blockSize);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr3, &ksize);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for border type
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    Mat new_image;
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0){
+           cornerEigenValsAndVecs(image, new_image, blockSize, ksize, BORDER_CONSTANT);
+       }
+    else if(strcmp(borderType[0], "BORDER_DEFAULT") == 0)
+    	cornerEigenValsAndVecs(image, new_image, blockSize, ksize, BORDER_DEFAULT);
+   free(borderType);
+
+   string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_cornerHarris.cpp b/sci_gateway1/cpp/opencv_cornerHarris.cpp
new file mode 100644
index 0000000..d517eec
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_cornerHarris.cpp
@@ -0,0 +1,144 @@
+/********************************************************
+Author: Shubheksha Jalan 
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  
+  int opencv_cornerHarris(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4 = NULL;
+    int *piAddr5 = NULL;
+    int i,j;
+    double blockSize, ksize, k;
+    char **borderType;
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1); 
+    cvtColor(image,image,CV_BGR2GRAY);
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &blockSize);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr3, &ksize);
+    if(intErr)
+    {
+        return intErr;
+    }   
+//for value of k 
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr4, &k);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for border type
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr5, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr5, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr5, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   cout<<"String\n";
+
+    Mat new_image(image.rows, image.cols, CV_32FC1);
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0){
+           cornerHarris(image, new_image, blockSize, ksize, k, BORDER_CONSTANT);
+       }
+    else if(strcmp(borderType[0], "BORDER_DEFAULT") == 0)
+    	cornerHarris(image, new_image, blockSize, ksize, k, BORDER_DEFAULT);
+
+    namedWindow ("window", 1);
+    imshow("window", new_image);
+    waitKey(0);
+    destroyWindow("window");
+
+    new_image.convertTo(new_image, CV_32FC1, 1.0/255.0);
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_cornerMinEigenVal.cpp b/sci_gateway1/cpp/opencv_cornerMinEigenVal.cpp
new file mode 100644
index 0000000..19123e5
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_cornerMinEigenVal.cpp
@@ -0,0 +1,125 @@
+/********************************************************
+Author: Shubheksha Jalan 
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  
+  int opencv_cornerMinEigenVal(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4 = NULL;
+    int i,j,k;
+    double blockSize, ksize;
+    char **borderType;
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1); 
+    cvtColor(image,image,CV_BGR2GRAY);
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &blockSize);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr3, &ksize);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for border type
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   cout<<"String\n";
+
+    Mat new_image;
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0){
+           cornerMinEigenVal(image, new_image, blockSize, ksize, BORDER_CONSTANT);
+       }
+    else if(strcmp(borderType[0], "BORDER_DEFAULT") == 0)
+    	cornerMinEigenVal(image, new_image, blockSize, ksize, BORDER_DEFAULT);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_cvtColor.cpp b/sci_gateway1/cpp/opencv_cvtColor.cpp
new file mode 100644
index 0000000..2959dda
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_cvtColor.cpp
@@ -0,0 +1,183 @@
+/********************************************************
+    Author: Shubheksha Jalan
+*********************************************************
+  void cvtColor(InputArray src, int code, int dstCn=0 )
+********************************************************/
+// number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code 
+
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "sciprint.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_cvtColor(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piLen = NULL;
+    double dstCn;
+    int code; 
+    char **codeString = NULL;
+    int i, j, k;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 2, 3);
+    CheckOutputArgument(pvApiCtx, 1,1) ;
+
+
+     Mat src;
+     retrieveImage(src,1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+     //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    codeString = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        codeString[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, codeString);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr){
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &dstCn);
+    if(intErr){
+        return intErr;
+    }
+
+     Mat dst;
+     
+    if(strcmp(codeString[0], "CV_BGR2GRAY") == 0)
+              code = CV_BGR2GRAY;
+    else if(strcmp(codeString[0], "CV_RGB2GRAY") == 0)
+              code = CV_RGB2GRAY;
+    else if(strcmp(codeString[0], "CV_GRAY2BGR") == 0)
+              code = CV_GRAY2BGR;        
+    else if(strcmp(codeString[0], "CV_GRAY2RGB") == 0)
+              code = CV_GRAY2RGB;
+    else if(strcmp(codeString[0], "CV_BGR2XYZ") == 0)
+              code = CV_BGR2XYZ;
+    else if(strcmp(codeString[0], "CV_RGB2XYZ") == 0)
+              code = CV_RGB2XYZ;
+    else if(strcmp(codeString[0], "CV_XYZ2BGR") == 0)
+              code = CV_XYZ2BGR;
+    else if(strcmp(codeString[0], "CV_XYZ2RGB") == 0)
+              code = CV_XYZ2RGB;
+    else if(strcmp(codeString[0], "CV_BGR2YCrCb") == 0)
+              code = CV_BGR2YCrCb;
+    else if(strcmp(codeString[0], "CV_RGB2YCrCb") == 0)
+              code = CV_RGB2YCrCb;
+    else if(strcmp(codeString[0], "CV_YCrCb2BGR") == 0)
+              code = CV_YCrCb2BGR;
+    else if(strcmp(codeString[0], "CV_YCrCb2RGB") == 0)
+              code = CV_YCrCb2RGB;
+    else if(strcmp(codeString[0], "CV_BGR2HSV") == 0)
+              code = CV_BGR2HSV;
+    else if(strcmp(codeString[0], "CV_RGB2HSV") == 0)
+              code = CV_RGB2HSV;
+    else if(strcmp(codeString[0], "CV_HSV2BGR") == 0)
+              code = CV_HSV2BGR;
+    else if(strcmp(codeString[0], "CV_HSV2RGB") == 0)
+              code = CV_HSV2RGB;
+    else if(strcmp(codeString[0], "CV_BGR2HLS") == 0)
+              code = CV_BGR2HLS;
+    else if(strcmp(codeString[0], "CV_RGB2HLS") == 0)
+              code = CV_RGB2HLS;
+    else if(strcmp(codeString[0], "CV_HLS2BGR") == 0)
+              code = CV_HLS2BGR;
+    else if(strcmp(codeString[0], "CV_HLS2RGB") == 0)
+              code = CV_HLS2RGB;
+    else if(strcmp(codeString[0], "CV_BGR2Lab") == 0)
+              code = CV_BGR2Lab;
+    else if(strcmp(codeString[0], "CV_RGB2Lab") == 0)
+              code = CV_RGB2Lab;
+    else if(strcmp(codeString[0], "CV_Lab2BGR") == 0)
+              code = CV_Lab2BGR;
+    else if(strcmp(codeString[0], "CV_Lab2RGB") == 0)
+              code = CV_Lab2RGB;
+    else if(strcmp(codeString[0], "CV_BGR2Luv") == 0)
+              code = CV_BGR2Luv;
+    else if(strcmp(codeString[0], "CV_RGB2Luv") == 0)
+              code = CV_RGB2Luv;
+    else if(strcmp(codeString[0], "CV_Luv2BGR") == 0)
+              code = CV_Luv2BGR;
+    else if(strcmp(codeString[0], "CV_Luv2RGB") == 0)
+              code = CV_Luv2RGB;
+    else{
+
+        sciprint("Invalid code");
+        return 0;
+    }
+    
+    cvtColor(src, dst, code, dstCn);
+
+    // namedWindow ("window", 1);
+    // imshow("window", dst);
+    // waitKey(0);
+    //  destroyWindow("window");
+
+
+    string tempstring = type2str(dst.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,dst,1); 
+    free(checker);
+
+
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_demosaic.cpp b/sci_gateway1/cpp/opencv_demosaic.cpp
new file mode 100644
index 0000000..4c2ee4b
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_demosaic.cpp
@@ -0,0 +1,127 @@
+/********************************************************
+    Author: V Srinivas
+*********************************************************
+  void cvtColor(InputArray src, int code, int dstCn=0 )
+********************************************************/
+//Demosaicing using cvt color filter
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "sciprint.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_demosaic(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piLen = NULL;
+    double dstCn;
+    int code; 
+    char **codeString = NULL;
+    int i, j, k;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 2,2);
+    CheckOutputArgument(pvApiCtx, 1,1) ;
+
+
+     Mat src;
+     retrieveImage(src,1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return -1;
+    }
+
+     //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return -1;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return -1;
+    }
+
+    codeString = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        codeString[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, codeString);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    
+
+     Mat dst;
+     
+    if(strcmp(codeString[0], "gbrg") == 0)
+              code = CV_BayerGR2RGB;
+    else if(strcmp(codeString[0], "bggr") == 0)
+              code = CV_BayerRG2RGB;
+    else if(strcmp(codeString[0], "rggb") == 0)
+              code = CV_BayerBG2RGB;        
+    else if(strcmp(codeString[0], "grbg") == 0)
+              code = CV_BayerGB2RGB;
+    else{
+
+        sciprint("Invalid Bayer filter code");
+        return 0;
+    }
+    
+    cvtColor(src, dst, code, 0);
+
+    // namedWindow ("window", 1);
+    // imshow("window", dst);
+    // waitKey(0);
+    //  destroyWindow("window");
+
+
+    string tempstring = type2str(dst.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,dst,1); 
+    free(checker);
+
+
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+}
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_detectBRISKFeatures.cpp b/sci_gateway1/cpp/opencv_detectBRISKFeatures.cpp
new file mode 100644
index 0000000..e6ded8e
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectBRISKFeatures.cpp
@@ -0,0 +1,421 @@
+/***************************************************
+Author : Shashank Shekhar
+***************************************************/
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+	int opencv_detectBRISKFeatures(char *fname, unsigned long fname_len)
+	{	
+
+		SciErr sciErr;
+		int *piAddr = NULL;
+		int *piAddrVal = NULL;
+    	int argPresence[4];
+    	for(int i=0;i<4;i++)
+	        argPresence[i]=0;
+	    int val_position;
+	    int iRows = 0;
+	    int iCols = 0;
+	    int *piLen = NULL;
+	    char ** pstData = NULL;
+    	char *currentArg = NULL;
+
+
+//  DECLARING INPUT ARGUMENTS
+
+		double *ROImat = NULL;
+		double NumOctaves = 0;
+		double MinContrast = 0;
+		double MinQuality = 0;
+
+
+//	DECLARING OUTPUT ARGUMENTS
+
+		vector<KeyPoint> myPoints;
+		int *LocationList = NULL;
+		double *LocationData = NULL;
+		double *OrientationData = NULL;
+		double *ScaleData = NULL;
+		double *MetricData = NULL;
+		int size;
+
+//	ARGUMENT CHECK
+
+		CheckInputArgument(pvApiCtx, 1,9);
+    	CheckOutputArgument(pvApiCtx,1,5);
+
+//	RETRIEVING IMAGE
+
+    	Mat image;
+    	retrieveImage(image,1);
+
+//  GRAYSCALE VALIDATION
+
+   	    if(image.channels()!=1)
+   	 	{
+    	    Scierror(999," Feature is not meant for RGB images\n");
+        	return 0;        
+    	}
+
+//	OBTAINING NUMBER OF ARGUMENTS
+
+    	int noOfarguments = *getNbInputArgument(pvApiCtx);
+
+//	ARGUMENT COUNT CHECK
+
+    	if(noOfarguments%2==0)
+   	 	{
+    	    Scierror(999," Invalid Number Of Arguments\n");
+        	return 0;        
+    	}
+
+//	MULTIPLE ARGUMENT HANDLING
+
+        for(int i=2;i<noOfarguments;i=i+2)
+            {
+                sciErr = getVarAddressFromPosition(pvApiCtx,i,&piAddr);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                if(!isStringType(pvApiCtx, piAddr))
+                {
+                    Scierror(999,"Invalid Argument\n");
+                    return 0;
+                }
+
+                //first call to get rows and columns 
+                sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+                //second call to retrieve length of each string
+                sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+                for(int j = 0 ; j < iRows * iCols ; j++)
+                {
+                    pstData[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));//+ 1 for null termination
+                }
+                //third call to retrieve data
+                sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                currentArg = pstData[0];
+                free(pstData);
+                iRows=0;
+                iCols=0;
+                free(piLen);
+
+                if(strcmp(currentArg,"MinContrast")==0)
+                {
+                    val_position=i+1;  
+                    
+                    if(argPresence[0]==1)
+                    {
+                        Scierror(999,"Do not enter the same parameter\n");
+                        return 0;
+                    }
+
+                    sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;   
+                    }
+
+                    if(!isDoubleType(pvApiCtx, piAddrVal))
+                    {
+                        Scierror(999,"Invalid Value for MinContrast. Please enter a value between 0 and 1\n");
+                        return 0;
+                    }     
+
+                    getScalarDouble(pvApiCtx, piAddrVal, &MinContrast);
+                    
+                    if(MinContrast<0 || MinContrast>1)
+                    {
+                        Scierror(999,"Invalid Value for MinContrast. Please enter a value between 0 and 1\n");
+                        return 0;
+                    }               
+                    
+                    argPresence[0]=1;       
+                }
+                else if(strcmp(currentArg,"NumOctaves")==0)
+                {
+                    val_position=i+1;           
+
+                    if(argPresence[1]==1)
+                    {
+                        Scierror(999,"Do not enter the same parameter\n");
+                        return 0;
+                    }
+
+                    sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    if(!isDoubleType(pvApiCtx, piAddrVal))
+                    {
+                        Scierror(999," Invalid Value for NumOctaves. Recommended values are between 1 and 4\n");
+                        return 0;
+                    }     
+
+                    getScalarDouble(pvApiCtx, piAddrVal, &NumOctaves);
+                    if(NumOctaves<1)
+                    {
+                        Scierror(999," Invalid Value for NumOctaves. Recommended values are between 1 and 4\n");
+                        return 0;
+                    }
+                    argPresence[1]=1;     
+                }
+                else if(strcmp(currentArg,"MinQuality")==0)
+                {
+                    val_position=i+1;
+                    
+                    
+                    if(argPresence[2]==1)
+                    {
+                        Scierror(999,"Do not enter the same parameter\n");
+                        return 0;
+                    }
+
+                    sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    if(!isDoubleType(pvApiCtx, piAddrVal))
+                    {
+                        Scierror(999," Invalid Value for MinQuality. Recommended values are between 0 and 1\n");
+                        return 0;
+                    }
+
+                    getScalarDouble(pvApiCtx, piAddrVal, &MinQuality);
+
+                    if(MinQuality<0 || MinQuality>1)
+                    {
+                        Scierror(999," Invalid Value for MinQuality. Please enter a value between 0 and 1   \n");
+                        return 0;
+                    }
+          
+                    argPresence[2]=1; 
+                }
+                else if(strcmp(currentArg,"ROI")==0)
+                {
+                    val_position=i+1;
+                    
+                    if(argPresence[3]==1)
+                    {
+                        Scierror(999,"Do not enter the same parameter\n");
+                        return 0;
+                    }
+                    
+                    sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx, piAddrVal))
+                    {
+                        Scierror(999,"Enter a List of 4 arguments\n");
+                        return 0;
+                    }
+
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddrVal, &iRows, &iCols, &ROImat);  
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+
+                    if(iRows*iCols!=4)
+                    {   
+                        Scierror(999,"Invalid Argument\n");
+                        return 0;
+                    }
+
+                    if(ROImat[0]<0 || ROImat[1]<0 || ROImat[2]<0 || ROImat[3]<0)
+                    {   
+                        Scierror(999,"Arguments cannot be negative\n");
+                        return 0;
+                    }       
+
+                    if(ROImat[0]>image.cols || ROImat[1]>image.rows || ROImat[0]+ROImat[2]>image.cols
+                        || ROImat[1]+ROImat[3]>image.rows) 
+                    {
+                        Scierror(999,"Please make sure the arguments are within the image range\n");
+                        return 0;
+                    }
+
+                    argPresence[3]=1;
+                }
+                else
+                {
+                    Scierror(999, "Error: \"%s\" Invalid input argument.\n", currentArg); 
+                    return 0; 
+                }
+
+            }
+
+
+//	DEFAULT ARGUMENTS
+
+            if(argPresence[0]==0)
+                MinContrast=0.2;
+            if(argPresence[1]==0)
+                NumOctaves=4;
+            if(argPresence[2]==0)
+                MinQuality=0.1;
+            if(argPresence[3]==0)
+            {
+                ROImat=(double *)malloc(sizeof(double)*1*4);
+                ROImat[0]=0;
+                ROImat[1]=0;
+                ROImat[2]=image.cols;
+                ROImat[3]=image.rows;       
+            }
+
+//	CREATING REGION OF INTEREST    
+
+            Rect masker(ROImat[0], ROImat[1], ROImat[2], ROImat[3]);
+            
+            Mat mask(image.size(), CV_8UC1, Scalar::all(0));
+            mask(masker).setTo(Scalar::all(255));
+
+//	PROCESSING BRISK
+
+
+    	// Setting Threshold ------------------------------------------------->
+
+    	double Threshold = MinContrast * 255;
+
+    	// Limiting NumOctaves ----------------------------------------------->
+
+	    int g = image.rows>image.cols?image.rows:image.cols;
+    	int maxNumOctaves = int(floor(log2(g)));
+    	if(NumOctaves>maxNumOctaves)
+    		NumOctaves=maxNumOctaves;
+
+    	//-----------------------------------------------------------------------
+
+        BRISK myobject(Threshold, NumOctaves);
+        myobject.operator()(image, mask, myPoints, noArray());
+
+        // Selecting Points according to MinQuality --------------------------->
+
+        size = myPoints.size();
+	
+	    double maxMetric = 0;
+        double minMetric = 0;
+
+        for(int i=0;i<size;i++)
+        {
+        	if(myPoints[i].response>maxMetric)
+        		maxMetric=myPoints[i].response;
+        }
+        minMetric = maxMetric*MinQuality;
+
+        int finalSize = 0;
+        for(int i=0;i<size;i++)
+        {
+        	if(myPoints[i].response>=minMetric)
+        		finalSize++;
+        }
+  
+  		//------------------------------------------------------------------------
+
+//	LOCATION   ---->
+
+    LocationData = (double *)malloc(sizeof(double)*finalSize*2);
+	MetricData = (double *)malloc(sizeof(double)*finalSize);
+	OrientationData = (double *)malloc(sizeof(double)*finalSize);
+	ScaleData = (double *)malloc(sizeof(double)*finalSize);
+    int k=0;
+    //   Appending 1x2 Matrices containing the coordinates of the keypoints, as well as assiging other attributes
+    for(int i=0;i<size;i++)
+    {
+    	if(myPoints[i].response>=minMetric)
+    	{	        
+	        LocationData[k++] = myPoints[i].pt.x;
+	        LocationData[k++] = myPoints[i].pt.y;
+	        OrientationData[i] = 0;    
+	        MetricData[i] = myPoints[i].response;
+	        ScaleData[i] = myPoints[i].size;	       
+   		}	
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, finalSize, 2, LocationData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+       
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, finalSize, 1, OrientationData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+       
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, finalSize,1, MetricData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 4,finalSize,1, ScaleData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }    
+
+    createScalarInteger32(pvApiCtx,nbInputArgument(pvApiCtx) + 5, finalSize);
+
+//	ASSIGNING   ---->
+
+    for(int i=1;i<=5;i++)
+    {
+ 		AssignOutputVariable(pvApiCtx, i) = nbInputArgument(pvApiCtx) + i;   	
+    }
+
+    ReturnArguments(pvApiCtx);
+	}
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_detectCheckerboardPoints.cpp b/sci_gateway1/cpp/opencv_detectCheckerboardPoints.cpp
new file mode 100644
index 0000000..33c951c
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectCheckerboardPoints.cpp
@@ -0,0 +1,731 @@
+/***************************************************
+Author      : Rohit Suri
+***************************************************/
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/calib3d/calib3d.hpp>
+#include <iostream>
+#include <vector>
+
+using namespace std;
+using namespace cv;
+
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include <sciprint.h>
+    #include "../common.h"
+    //function used to retrieve image matrix from Scilab environment
+    int retrieveImageFromAddress(Mat &image,int *piAddr)
+    {
+        SciErr sciErr;
+        int iRows=0,iCols=0,i,j,k=0;
+        int *piChild = NULL;
+        int iPrec = 0,iItem = 0;
+        sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piChild);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(isIntegerType(pvApiCtx, piChild))
+        {
+            //getting precision
+            sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piChild, &iPrec);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            switch(iPrec)
+            {
+                case SCI_UINT8: //for unsigned integer 8
+                {
+                    if(iItem==3)
+                    {
+                        unsigned char *pstDataR = NULL;
+                        unsigned char *pstDataG = NULL;
+                        unsigned char *pstDataB = NULL;
+                        //retrive the matrix of the R values
+                        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        //retrive the matrix of the G values
+                        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        //retrive the matrix of the B values
+                        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+
+                        //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                        image = Mat(iRows,iCols,CV_8UC3);
+
+                        /*Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this*/
+                        k=0;
+                        for(i=0;i<iRows;i++)
+                        {
+                            for(j=0;j<iCols;j++)
+                            {
+                              image.at<Vec3b>(i,j)[2]=pstDataR[i+iRows*j];
+                              image.at<Vec3b>(i,j)[1]=pstDataG[i+iRows*j];
+                              image.at<Vec3b>(i,j)[0]=pstDataB[i+iRows*j];
+                            }
+                        }
+                    }
+                    else
+                    {
+                        unsigned char *pstDataR = NULL;
+                        //retrive the matrix of the R values
+                        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+
+                        //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                        image = Mat(iRows,iCols,CV_8UC1);
+
+                        //Assigning matrix value to pixel
+                        k=0;
+                        for(i=0;i<iRows;i++)
+                            for(j=0;j<iCols;j++)
+                              image.at<uchar>(i,j)=pstDataR[i+iRows*j];
+                    }
+                    break;
+                }
+                case SCI_UINT16: //for unsigned integer 16
+                {
+                    if(iItem==3)
+                    {
+                        short unsigned int *pstDataR = NULL;
+                        short unsigned int *pstDataG = NULL;
+                        short unsigned int *pstDataB = NULL;
+                        //retrive the matrix of the R values
+                        sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        //retrive the matrix of the G values
+                        sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        //retrive the matrix of the B values
+                        sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+
+                        //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                        image = Mat(iRows,iCols,CV_16UC3);
+
+                        //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                        k=0;
+                        for(i=0;i<iRows;i++)
+                        {
+                            for(j=0;j<iCols;j++)
+                            {
+                              image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                              image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                              image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                         //i+iRows*j
+                            }
+                        }
+                    }
+                    else
+                    {
+                        short unsigned int *pstDataR = NULL;
+                        //retrive the matrix of the R values
+                        sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+
+                        //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                        image = Mat(iRows,iCols,CV_16UC1);
+
+                        //Assigning matrix values to pixels
+                        k=0;
+                        for(i=0;i<iRows;i++)
+                            for(j=0;j<iCols;j++)
+                              image.at<ushort>(i,j)=pstDataR[i+iRows*j];
+                    }
+                    break;
+                }
+                case SCI_INT16: //for signed integer 16
+                {
+                    if(iItem==3)
+                    {
+                        short int *pstDataR = NULL;
+                        short int *pstDataG = NULL;
+                        short int *pstDataB = NULL;
+                        //retrive the matrix of the R values
+                        sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        //retrive the matrix of the G values
+                        sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        //retrive the matrix of the B values
+                        sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+
+                        //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                        image = Mat(iRows,iCols,CV_16SC3);
+
+                        //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                        k=0;
+                        for(i=0;i<iRows;i++)
+                        {
+                            for(j=0;j<iCols;j++)
+                            {
+                              image.at<Vec3s>(i,j)[2]=pstDataR[i+iRows*j];
+                              image.at<Vec3s>(i,j)[1]=pstDataG[i+iRows*j];
+                              image.at<Vec3s>(i,j)[0]=pstDataB[i+iRows*j];
+                            }
+                        }
+                    }
+                    else
+                    {
+                        short int *pstDataR = NULL;
+                        //retrive the matrix of the R values
+                        sciErr = getMatrixOfInteger16InList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+
+                        //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                        image = Mat(iRows,iCols,CV_16SC1);
+
+                        //Assigning image matrix values to pixels
+                        k=0;
+                        for(i=0;i<iRows;i++)
+                            for(j=0;j<iCols;j++)
+                              image.at<short>(i,j)=pstDataR[i+iRows*j];
+                    }
+                    break;
+                }
+            }
+        }
+        else //for floating point/ double precision values
+        {
+            if(iItem==3)
+            {
+                double *pstDataR = NULL;
+                double *pstDataG = NULL;
+                double *pstDataB = NULL;
+                //retrive the matrix of the R values
+                sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                //retrive the matrix of the G values
+                sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 2, &iRows, &iCols, &pstDataG);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                //retrive the matrix of the B values
+                sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 3, &iRows, &iCols, &pstDataB);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                image = Mat(iRows,iCols,CV_64FC3);
+
+                //Now that we have the 3 matrices(R,G,B), we need to assign those values to the pixels. The following code does this
+                k=0;
+                for(i=0;i<iRows;i++)
+                {
+                    for(j=0;j<iCols;j++)
+                    {
+                        image.at<Vec3d>(i,j)[2]=pstDataR[i+iRows*j];
+                        image.at<Vec3d>(i,j)[1]=pstDataG[i+iRows*j];
+                        image.at<Vec3d>(i,j)[0]=pstDataB[i+iRows*j];
+                    }
+                }
+            }
+            else
+            {
+                double *pstDataR = NULL;
+                //retrive the matrix of the R values
+                sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr, 1, &iRows, &iCols, &pstDataR);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                //creating an image matrix with the no. of rows and columns we retrieved, and assigning it to be of the form 8-bit unsinged integers
+                image = Mat(iRows,iCols,CV_64FC1);
+
+                //Assigning image matrix values to pixels
+                k=0;
+                for(i=0;i<iRows;i++)
+                    for(j=0;j<iCols;j++)
+                        image.at<double>(i,j)=pstDataR[i+iRows*j];
+            }
+            }
+        return 1;
+    }
+    int opencv_detectCheckerboardPoints(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+
+        SciErr sciErr;
+
+        //------Local variables------//
+
+        int *piAddr;
+        int *piChild;
+        int *piGrandChild;
+        int iItem;
+        int iItemInner;
+        int argCount;
+        int iRows,iCols;
+        int *piLen;
+        char **pstData;
+
+        int imgCount[2]={0};
+        int returnSize[2];
+        vector<Mat> inputs;
+        Mat inp;
+        vector<vector<Point2f> > chessboardPoints;
+        vector<Size> chessboardSize;
+        vector<Point2f> v;
+        bool detected;
+        int *usedImages;
+        int ***points;
+        int count = 0,pointsPos;
+        //------Check number of parameters------//
+
+        CheckInputArgument(pvApiCtx, 1, 2);
+		CheckOutputArgument(pvApiCtx, 2, 3);
+        argCount = *getNbInputArgument(pvApiCtx);
+
+        //------Get input arguments------//
+
+        for(int iter=0;iter<argCount;iter++)
+        {
+            sciErr = getVarAddressFromPosition(pvApiCtx,iter+1,&piAddr);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            if(isStringType(pvApiCtx,piAddr))
+            {
+                sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                if(iRows!=1)
+                {
+                    Scierror(999, "Incorrect type of input argument(s).\n");
+                    return 0;
+                }
+                imgCount[iter]=iCols;
+            }
+            else if(isListType(pvApiCtx,piAddr))
+            {
+                sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piChild);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                if(isIntegerType(pvApiCtx,piChild) || isDoubleType(pvApiCtx,piChild))
+                {
+                    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    if(iItem==1 || iItem==3)
+                    {
+                        for(int i=1;i<=iItem;i++)
+                        {
+                            sciErr = getListItemAddress(pvApiCtx,piAddr,i,&piChild);
+                            if(sciErr.iErr)
+                            {
+                                printError(&sciErr, 0);
+                                return 0;
+                            }
+                            if(isIntegerType(pvApiCtx,piChild) || isDoubleType(pvApiCtx,piChild))
+                            {
+                                continue;
+                            }
+                            else
+                            {
+                                Scierror(999, "Incorrect type of input argument(s).\n");
+                                return 0;
+                            }
+                        }
+                        imgCount[iter]=1;
+                    }
+                    else
+                    {
+                        Scierror(999, "Incorrect type of input argument(s).\n");
+                        return 0;
+                    }
+                }
+                else if(isListType(pvApiCtx,piChild))
+                {
+                    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    for(int i=1;i<=iItem;i++)
+                    {
+                        sciErr = getListItemAddress(pvApiCtx,piAddr,i,&piChild);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        if(isListType(pvApiCtx,piChild))
+                        {
+                            sciErr = getListItemNumber(pvApiCtx,piChild,&iItemInner);
+                            if(sciErr.iErr)
+                            {
+                                printError(&sciErr, 0);
+                                return 0;
+                            }
+                            if(iItemInner==1 || iItemInner==3)
+                            {
+                                for(int j=1;j<=iItemInner;j++)
+                                {
+                                    sciErr = getListItemAddress(pvApiCtx,piChild,j,&piGrandChild);
+                                    if(sciErr.iErr)
+                                    {
+                                        printError(&sciErr, 0);
+                                        return 0;
+                                    }
+                                    if(isIntegerType(pvApiCtx,piGrandChild) || isDoubleType(pvApiCtx,piGrandChild))
+                                    {
+                                        continue;
+                                    }
+                                    else
+                                    {
+                                        Scierror(999, "Incorrect type of input argument(s).\n");
+                                        return 0;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                Scierror(999, "Incorrect type of input argument(s).\n");
+                                return 0;
+                            }
+                        }
+                        else
+                        {
+                            Scierror(999, "Incorrect type of input argument(s).\n");
+                            return 0;
+                        }
+                    }
+                    imgCount[iter]=iItem;
+                }
+                else
+                {
+                    Scierror(999, "Incorrect type of input argument(s).\n");
+                    return 0;
+                }
+            }
+            else
+            {
+                Scierror(999, "Incorrect type of input argument(s).\n");
+                return 0;
+            }
+        }
+        if(argCount==2 && imgCount[0]!=imgCount[1])
+        {
+            Scierror(999,"For Stereo Calibration, both image sets must have same number of images.\n");
+            return 0;
+        }
+        for(int iter=0;iter<argCount;iter++)
+        {
+            sciErr = getVarAddressFromPosition(pvApiCtx,iter+1,&piAddr);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            if(isStringType(pvApiCtx,piAddr))
+            {
+                sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+                sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+                for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+                {
+                    pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+                }
+
+                sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+
+                for(int i=0;i<iCols;i++)
+                {
+                    inp = imread(pstData[i]);
+                    if(!inp.data)
+                    {
+                        Scierror(999,"Cannot read image \'%s\'. Aborting.\n",pstData[i]);
+                        return 0;
+                    }
+                    inputs.push_back(inp);
+                }
+            }
+            else
+            {
+                sciErr = getListItemAddress(pvApiCtx,piAddr,1,&piChild);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                if(isIntegerType(pvApiCtx,piChild) || isDoubleType(pvApiCtx,piChild))
+                {
+                    retrieveImageFromAddress(inp,piAddr);
+                    inputs.push_back(inp);
+                }
+                else
+                {
+                    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    for(int i=1;i<=iItem;i++)
+                    {
+                        sciErr = getListItemAddress(pvApiCtx,piAddr,i,&piChild);
+                        if(sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 0;
+                        }
+                        retrieveImageFromAddress(inp,piChild);
+                        inputs.push_back(inp);
+                    }
+                }
+            }
+        }
+
+        //------Actual processing------//
+
+        for(int iter=0;iter<inputs.size();iter++)
+        {
+            v.clear();
+            detected = 0;
+            for(int i=14;i>=3;i--)
+            {
+                for(int j=14;j>=i;j--)
+                {
+                    Size boardsize(i,j);
+                    detected = findChessboardCorners(inputs[iter],boardsize,v);
+                    if(detected)
+                    {
+                        chessboardPoints.push_back(v);
+                        chessboardSize.push_back(Size(i+1,j+1));
+                        break;
+                    }
+                }
+                if(detected)
+                    break;
+            }
+            if(!detected)
+            {
+                chessboardPoints.push_back(v);
+            }
+        }
+        if(chessboardSize.size()==0)
+        {
+            Scierror(999, "No chessboards detected. Aborting.");
+            return 0;
+        }
+        Size compare = chessboardSize[0];
+        for(int i=1;i<chessboardSize.size();i++)
+        {
+            if(compare.height!=chessboardSize[i].height || compare.width!=chessboardSize[i].width)
+            {
+                Scierror(999, "Chessboards of different sizes detected. Aborting.");
+                return 0;
+            }
+        }
+        usedImages= (int*) malloc(sizeof(int)*imgCount[0]);
+        for(int i=0;i<imgCount[0];i++)
+        {
+            if(chessboardPoints[i].size() == 0)
+            {
+                usedImages[i] = 0;
+            }
+            else
+            {
+                usedImages[i] = 1;
+            }
+        }
+        if(argCount==2)
+        {
+            for(int i=0;i<imgCount[0];i++)
+            {
+                if(chessboardPoints[i+imgCount[0]].size() == 0)
+                {
+                    usedImages[i] = 0;
+                }
+            }
+        }
+        for(int i=0;i<imgCount[0];i++)
+        {
+            if(usedImages[i]==1)
+            {
+                count++;
+            }
+        }
+        points = (int***) malloc(sizeof(int**)*argCount);
+        for(int i=0;i<argCount;i++)
+        {
+            points[i] = (int**) malloc(sizeof(int*)*count);
+        }
+        pointsPos = 0;
+        for(int i=0;i<imgCount[0];i++)
+        {
+            if(usedImages[i])
+            {
+                points[0][pointsPos] = (int*) malloc(sizeof(int) * chessboardPoints[i].size() * 2);
+                if(argCount==2)
+                {
+                    points[1][pointsPos] = (int*) malloc(sizeof(int) * chessboardPoints[i].size() * 2);
+                }
+                for(int j=0;j<chessboardPoints[i].size();j++)
+                {
+                    points[0][pointsPos][j] = chessboardPoints[i][j].x;
+                    points[0][pointsPos][chessboardPoints[i].size()+j] = chessboardPoints[i][j].y;
+                    if(argCount==2)
+                    {
+                        points[1][pointsPos][j] = chessboardPoints[imgCount[0]+i][j].x;
+                        points[1][pointsPos][chessboardPoints[i].size()+j] = chessboardPoints[imgCount[0]+i][j].y;
+                    }
+                }
+                pointsPos++;
+            }
+        }
+        returnSize[0] = compare.width;
+        returnSize[1] = compare.height;
+        //------Create output arguments------//
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, argCount, &piAddr);
+        if(sciErr.iErr)
+	    {
+		    printError(&sciErr, 0);
+		    return 0;
+	    }
+        for(int i=0;i<argCount;i++)
+        {
+            sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, i+1, pointsPos, &piChild);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            for(int j=0;j<pointsPos;j++)
+            {
+                sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piChild, j+1, (returnSize[0]-1)*(returnSize[1]-1), 2, points[i][j]);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+            }
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+2, 1, 2, returnSize);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+3, 1, imgCount[0], usedImages);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2;
+        AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3;
+        ReturnArguments(pvApiCtx);
+		return 0;
+    }
+    /* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_detectFASTFeatures.cpp b/sci_gateway1/cpp/opencv_detectFASTFeatures.cpp
new file mode 100644
index 0000000..19355fd
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectFASTFeatures.cpp
@@ -0,0 +1,569 @@
+/*************************************************************************************************************************************************************************************************
+*	Author: Umang Agrawal																					 *
+*	Code: detectFASTFeatures.cpp																				 *
+*	Function Format: detectFASTFeatures( Image, Optional Arguments... )															 *
+* 		Requirements: 		Image should be a grayscale image															 *
+*		Optional Arguments:	1. 'MinContrast'	Value: Range 0 < x < 1														 *
+*					2. 'MinQuality'		Value: Range 0 < x < 1														 *
+*					3. 'ROI'		Value: [ x_cordinate, y_cordinate, width, height ]										 *
+*************************************************************************************************************************************************************************************************/
+
+
+#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"
+
+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"
+
+	// Function using OpenCV to detect FAST Features
+	int opencv_detectFASTFeatures(char *fname, unsigned long fname_len)
+	{
+		int *piAddr = NULL;
+
+		//Various Declarations
+		SciErr sciErr;			//Error Variable
+		int sca_read;			//Error Variable
+
+		int *imgAddr = NULL;		//Address of the Image List Argument
+		int *piAddrChild = NULL;	//Address of the Child of the Image Matrix List
+		int no_item_list;		//Number of items in the list
+
+		int iPrec = 0;			//Precesision of the image in the lsit
+		int iRows=0, iCols=0;		//Rows & Columns in the image
+
+		int inp_params;			//Number of Input Arguments
+		int *piAddr1 = NULL;		//Address of Argument Head
+		int *piAddr2 = NULL;		//Address of Value_1 of Argument
+		//int *piAddr3 = NULL;		//Address of Value_2 of Argument
+		//int *piAddr4 = NULL;		//Address of Value_3 of Argument
+		//int *piAddr5 = NULL;		//Address of Value_4 of Argument
+		int Rows,Cols;			//Rows & Columns of String Matrix
+		int *len = NULL;		//Length of each String Element
+		char **arg;			//String Argument
+		double *roi_arg = NULL;		//ROI Argument Matrix Address
+		int rows,cols;			//Rows and Columns of ROI value matrix
+
+		//int *point = NULL;		//Points returned by the FAST Algorithm
+
+		double arg_val;			//Variables for Contrast/Quality Argument
+		double x = 0, y = 0, width, height;	//Variables for ROI Argument
+
+		double thresh;			//Effective Threshold
+		double thresh_c = 0;		//Threshold due to arguments
+		double thresh_q = 0;		//Threshold due to arguments
+
+		int count_q = 0;		//Count of Argument Quality Call
+		int count_c = 0;		//Count of Argument Contrast Call
+		int count_r = 0;		//Count of Argument ROI call
+
+		vector<KeyPoint> keypoints;	//Keypoint Vector to store the points returned by FAST Algorithm
+
+		int i,j;			//Iterators
+
+		double count = 0;			//Count of number of Features Detected
+		double *metric = NULL;
+
+		Mat image;			//Image Container
+		Mat cropped;			//Image Container
+
+		//Checks on Input and Output Arguments
+		CheckInputArgument(pvApiCtx, 1, 7);
+		CheckOutputArgument(pvApiCtx, 1, 3);
+
+
+		//Image Retrieval
+		//Get Address of the Image List
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &imgAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		//Get Number of items in the list
+		sciErr = getListItemNumber(pvApiCtx, imgAddr, &no_item_list);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		//Check if it is a Grayscal image by checking whether 1 item is present in the list
+		if( no_item_list == 1)
+		{
+			//Address of the Grayscale Matrix
+			sciErr = getListItemAddress(pvApiCtx, imgAddr, 1, &piAddrChild);
+    			if(sciErr.iErr)
+    			{
+        			printError(&sciErr, 0);
+        			return 0;
+    			}
+			//Check whether it is an integer Matrix or not
+			if(isIntegerType(pvApiCtx, piAddrChild))
+    			{
+        			//If integer matrix getting precision
+        			sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddrChild, &iPrec);
+        			if(sciErr.iErr)
+        			{
+            			printError(&sciErr, 0);
+            			return 0;
+        			}
+				//Based on precision Read the matrix
+        			switch(iPrec)
+				{
+				case SCI_UINT8: //for unsigned integer 8
+            				{
+					unsigned char *pstDatagray = NULL;
+               				sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, imgAddr, 1, &iRows, &iCols, &pstDatagray);
+               				if(sciErr.iErr)
+               				{
+                       				printError(&sciErr, 0);
+                       				return 0;
+               				}
+					image = Mat(iRows,iCols,CV_8UC1);
+					for(i=0;i<iRows;i++)
+                       				for(j=0;j<iCols;j++)
+                       					image.at<uchar>(i,j)=pstDatagray[i+iRows*j];
+					break;
+					}
+            			case SCI_UINT16: //for unsigned integer 16
+            				{
+                    			short unsigned int *pstDatagray = NULL;
+                    			sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, imgAddr, 1, &iRows, &iCols, &pstDatagray);
+                    			if(sciErr.iErr)
+                    			{
+                        			printError(&sciErr, 0);
+                        			return 0;
+                    			}
+                               		image = Mat(iRows,iCols,CV_16UC1);
+                    			for(i=0;i<iRows;i++)
+                        			for(j=0;j<iCols;j++)
+                       					image.at<ushort>(i,j)=pstDatagray[i+iRows*j];
+                			break;
+            				}
+            			case SCI_INT32: //for unsigned integer 32
+            				{
+                    			int *pstDatagray = NULL;
+                    			sciErr = getMatrixOfInteger32InList(pvApiCtx, imgAddr, 1, &iRows, &iCols, &pstDatagray);
+                    			if(sciErr.iErr)
+                    			{
+                        			printError(&sciErr, 0);
+                        			return 0;
+                    			}
+		                    	image = Mat(iRows,iCols,CV_32SC1);
+               				for(i=0;i<iRows;i++)
+                       				for(j=0;j<iCols;j++)
+                       					image.at<int>(i,j)=pstDatagray[i+iRows*j];
+       	 				break;
+       					}
+				}
+			}
+			else
+                	{
+				//If not Integer then must be double
+                        	double *pstDatagray = NULL;
+                        	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &imgAddr);
+                        	if(sciErr.iErr)
+                        	{
+                              		printError(&sciErr, 0);
+                               		return 0;
+                       		}
+                       		sciErr = getMatrixOfDoubleInList(pvApiCtx, imgAddr, 1, &iRows, &iCols, &pstDatagray);
+                       		if(sciErr.iErr)
+                       		{
+                               		printError(&sciErr, 0);
+                               		return 0;
+                       		}
+                       		image = Mat(iRows,iCols,CV_64FC1);
+                       		for(i=0;i<iRows;i++)
+                               		for(j=0;j<iCols;j++)
+                                       		image.at<double>(i,j)=pstDatagray[i+iRows*j];
+               		}
+		}
+		//If not single element in list than it is not a grayscale image and hence error
+		else
+		{
+			Scierror(999,"Expecting a single Matrix in grayscale format\n");
+			return 0;
+		}
+
+		//Get the Number of Arguments
+		inp_params = *getNbInputArgument(pvApiCtx);
+
+		//Based on Number of Arguments Evaluate each Argument
+		for(i=2; i<inp_params; i++)
+		{
+			//Reading the Name of the Argument
+			sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddr1);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			//Check for Argument type
+			if( !isStringType(pvApiCtx, piAddr1))
+			{
+				Scierror(999, "%s: Wrong type of argument #%d. A string is expected.\n", fname, 1);
+				return 0;
+			}
+			//Matrix of Stings
+			sciErr = getMatrixOfString(pvApiCtx, piAddr1, &Rows, &Cols, NULL, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			len = (int*)malloc(sizeof(int) * Rows * Cols);
+			//second call to retrieve the length of the string
+			sciErr = getMatrixOfString(pvApiCtx, piAddr1, &Rows, &Cols, len, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(len);
+				return 0;
+			}
+			arg = (char**)malloc(sizeof(char*) * Rows * Cols);
+			for(int j=0;j< Rows * Cols; j++)
+			{
+				arg[j] = (char*)malloc(sizeof(char) * (len[j] + 1));
+			}
+
+			//third call to retrieve data
+			sciErr = getMatrixOfString(pvApiCtx, piAddr1, &Rows, &Cols, len, arg);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(len);
+				free(arg);
+				return 0;
+			}
+
+			//Evaluating the Read Arguments Name
+			//MinContrast Argument
+			if(strcmp(arg[0],"MinContrast") == 0)
+			{
+				if(count_c == 0)
+				{
+				sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr2);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Checking the type of value
+				if( !isDoubleType(pvApiCtx, piAddr2))
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				//Reading the Value of the argument
+				sca_read = getScalarDouble(pvApiCtx, piAddr2, &arg_val);
+				if(sca_read)
+				{
+					Scierror(999,"Not a valid value.\n");
+					return 0;
+				}
+				//Check for valid range
+				if(arg_val<0 && arg_val>=1)
+				{
+					Scierror(999,"Not a valid range.Should be between 0 and 1.\n");
+					return 0;
+				}
+				//Threshold Calculation
+				else thresh_c = 256*arg_val;
+				i++;							//Incrementing iterator to count for the value argument read
+				count_c += 1;						//Indicating MinContrast has been called once
+				}
+				else
+				{
+					Scierror(999,"Specified MinContrast twice. Check Arguments\n");
+					return 0;
+				}
+			}
+			//MinQuality Argument
+			else if(strcmp(arg[0],"MinQuality") == 0)
+			{
+				if(count_q == 0)
+				{
+				sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr2);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Checking the type of Value
+				if( !isDoubleType(pvApiCtx, piAddr2))
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				//Reading the Value of argument
+				sca_read = getScalarDouble(pvApiCtx, piAddr2, &arg_val);
+				if(sca_read)
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				//Cheack for valid range
+				if(arg_val<0 && arg_val>=1)
+				{
+					Scierror(999,"Not a valid range.Should be between 0 and 1.\n");
+					return 0;
+				}
+				//Threshold Calculation
+				else thresh_q = 240*arg_val;
+				i++;							//Incrementing iterator to count for the value argument read
+				count_q += 1;						//Indicating MinQuality has been called once
+				}
+				else
+				{
+					Scierror(999,"Specified MinQuality twice. Check Arguments\n");
+					return 0;
+				}
+			}
+			//ROI Argument
+			else if(strcmp(arg[0],"ROI") == 0)
+			{
+				if(count_r == 0)
+				{
+				sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr2);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Checking the type of argument
+				if( !isDoubleType(pvApiCtx, piAddr2))
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				//Reading the Value of the argument
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &rows, &cols, &roi_arg);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Assigning the elements of the list to their proper function
+				x = roi_arg[0];
+				y = roi_arg[1];
+				width = roi_arg[2];
+				height = roi_arg[3];
+
+
+				//Code for reading the value associated with ROI individually rather than in a list form
+
+				/*sca_read = getScalarDouble(pvApiCtx, piAddr2, &x);
+				if(sca_read)
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				sciErr = getVarAddressFromPosition(pvApiCtx, i+2, &piAddr3);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				sca_read = getScalarDouble(pvApiCtx, piAddr3, &y);
+				if(sca_read)
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				sciErr = getVarAddressFromPosition(pvApiCtx, i+3, &piAddr4);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				sca_read = getScalarDouble(pvApiCtx, piAddr4, &width);
+				if(sca_read)
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}
+				sciErr = getVarAddressFromPosition(pvApiCtx, i+4, &piAddr5);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				sca_read = getScalarDouble(pvApiCtx, piAddr5, &height);
+				if(sca_read)
+				{
+					Scierror(999,"Not a valid type of value.\n");
+					return 0;
+				}*/
+
+				//Checking for valid crop area
+				if(x>=image.cols || y>=image.rows || x<0 || y<0)
+   			 	{
+        				sciprint("Invalid x or y value\n");
+        				return 0;
+    				}
+    				if(width<=0 || height<=0 || x+width > image.cols || y+height > image.rows)
+    				{
+        				sciprint("Invalid width or height value\n");
+        				return 0;
+    				}
+				//Croppint the image
+				Rect myROI(x, y, width, height);
+				Mat croppedRef(image, myROI);
+				croppedRef.copyTo(cropped);
+				i++;						//Incrementing iterator to count for the value argument read
+				count_r += 1;						//Indicating ROI has been called once
+				}
+				else
+				{
+					Scierror(999,"Specified ROC twice. Check Arguments\n");
+					return 0;
+				}
+			}
+			else
+			{
+				Scierror(999,"Invalid Argument\n");
+				return 0;
+			}
+
+		}
+
+		//Calculating the effective threshold by selecting the maximum threshold
+		if(thresh_c > 0 && thresh_c >= thresh_q)
+			thresh = thresh_c;
+		else if(thresh_q > 0 && thresh_q > thresh_c)
+			thresh = thresh_q;
+		else thresh = 256*0.2;
+
+		//Implementing FAST Algorithm
+		if(count_r != 0)
+			FAST(cropped, keypoints, thresh, 1);
+		else
+			FAST(image, keypoints, thresh, 1);
+
+		count = keypoints.size();
+
+		metric = (double*)malloc(sizeof(double)*keypoints.size()*1);
+		for( i=0; i<keypoints.size(); i++)
+		{
+			metric[i] = keypoints[i].response;
+		}
+
+		//Returning the obtained point co-ordinates
+		//Checking what type of Input matrix image was
+		//If input matrix was integer
+		if(isIntegerType(pvApiCtx, piAddrChild))
+		{
+			//Based on Precision of the Image given in input
+			switch(iPrec)
+                                {
+				case SCI_UINT8: {
+							//Output point Matrix
+							unsigned char *point = (unsigned char *)malloc(keypoints.size()*2*sizeof(char));
+							for(i=0;i!=keypoints.size();i++)
+         				      		{
+                        					point[i] = keypoints[i].pt.x + x;
+                        					point[keypoints.size()+i] = keypoints[i].pt.y + y;
+               						}
+							sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, int(keypoints.size()), 2, point);
+							if(sciErr.iErr)
+							{
+								printError(&sciErr, 0);
+								return 0;
+							}
+							free(point);
+							break;
+						}
+				case SCI_UINT16:{
+							//Output point Matrix
+							unsigned short *point = (unsigned short *)malloc(keypoints.size()*2*sizeof(short));
+							for(i=0;i!=keypoints.size();i++)
+                					{
+                        					point[i] = keypoints[i].pt.x + x;
+                        					point[keypoints.size()+i] = keypoints[i].pt.y + y;
+                					}
+							sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 1, int(keypoints.size()), 2, point);
+							if(sciErr.iErr)
+							{
+								printError(&sciErr, 0);
+								return 0;
+							}
+							free(point);
+							break;
+						}
+				case SCI_INT32: {
+							//Output Point Matrix
+							int *point = (int *)malloc(keypoints.size()*2*sizeof(int));
+							for(i=0;i!=keypoints.size();i++)
+                					{
+                        					point[i] = keypoints[i].pt.x + x;
+                        					point[keypoints.size()+i] = keypoints[i].pt.y + y;
+                					}
+							sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 1, int(keypoints.size()), 2, point);
+							if(sciErr.iErr)
+							{
+								printError(&sciErr, 0);
+								return 0;
+							}
+							free(point);
+							break;
+						}
+				}
+		}
+		//If not Integer than must be double input image
+		else
+		{
+			//Ouput point matrix
+			double *point = (double *)malloc(keypoints.size()*2*sizeof(double));
+			for(i=0;i!=keypoints.size();i++)
+                	{
+                        	point[i] = keypoints[i].pt.x + x;
+                    	    	point[keypoints.size()+i] = keypoints[i].pt.y + y;
+                	}
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, keypoints.size(), 2, point);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			free(point);
+		}
+
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 1, &count);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, keypoints.size(), 1, metric);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Returning the Output Matrix
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+		AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
diff --git a/sci_gateway1/cpp/opencv_detectHarrisFeatures.cpp b/sci_gateway1/cpp/opencv_detectHarrisFeatures.cpp
new file mode 100644
index 0000000..090ba5b
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectHarrisFeatures.cpp
@@ -0,0 +1,402 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <math.h>
+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"
+
+    /* Calling syntax: detectHarrisFeatures(I) or detectHarrisFeatures(I, Name, Value)
+       which uses additional options specified by one or more Name, Value pair arguments.
+       Arguments Allowed: MinQuality, FilterSize, ROI, SensitivityFactor
+       MinQuality        : The minimum accepted quality of corners represents a fraction of the
+                           maximum corner metric value in the image. Larger values can be used
+                           to remove erroneous corners.
+       FilterSize        : Gaussian filter dimension
+       ROI               : Rectangular region for corner detection
+       SensitivityFactor : A scalar value, K, where 0 < K < 0.25, specifying the sensitivity
+                           factor used in the Harris detection algorithm.                          */
+
+    int opencv_detectHarrisFeatures(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr;
+        int intErr;
+
+        //------Local variables------//
+        int *location = NULL;
+        double *metric = NULL;
+        int *piAddr = NULL;
+        int *piLen = NULL;
+        int nbInputArguments;
+        char **pstData = NULL;
+        char *currentArg = NULL;
+        bool *providedArgs = NULL;
+        double *matrixOfRoi;  // ROI[xStart, yStart, width, height]
+        int iRows, iCols;
+        Mat sourceImage, dst, dstThresholded, ucharDstThresholded, extended;
+        vector<vector<Point> > contours;
+        double filterSize = 5, minQuality = 0.01, sensitivityFactor = 0.04, blockSize = 2, maxDst, localMax;
+        bool *included = NULL;
+        int pointCount = 0, localMaxPos;
+        double tempForSwapping;
+        int coordinateMin, coordinatePos;
+
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 1, 9);
+        CheckOutputArgument(pvApiCtx, 1, 3);
+
+        //------Get input arguments------//
+        retrieveImage(sourceImage, 1);
+        if(sourceImage.channels() != 1)
+        {
+            Scierror(999, "The input image is not a grayscale image.");
+            return 0;
+        }
+        matrixOfRoi = (double*) malloc(sizeof(double) * 4);
+        providedArgs = (bool*) malloc(sizeof(bool) * 4);
+        memset(providedArgs, 0, 4);
+        matrixOfRoi[0] = 0;
+        matrixOfRoi[1] = 0;
+        matrixOfRoi[2] = sourceImage.cols;
+        matrixOfRoi[3] = sourceImage.rows;
+        nbInputArguments = *getNbInputArgument(pvApiCtx);
+
+        // The following loop is for checking if optional arguments have been provided
+        for(int iter=2; iter <= nbInputArguments; iter++)
+        {
+            // Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            // Extracting name of next argument takes three calls to getMatrixOfString
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+            }
+
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            currentArg = pstData[0];
+            // providedArgs[] makes sure that no optional argument is provided more than once
+            if(strcmp(currentArg, "MinQuality")==0)
+            {
+                if(iter+1<=nbInputArguments && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &minQuality);
+                    if(intErr)
+                    {
+                        return intErr;
+                    }
+                    // Checking if values are in proper range. Same for all optional arguments
+                    if(minQuality < 0 || minQuality > 1)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible range is [0, 1].\n", currentArg);
+                        return 0;
+                    }
+                    providedArgs[0] = 1;
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n");
+                    return 0;
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n");
+                    return 0;
+                }
+            }
+            else if(strcmp(currentArg, "FilterSize")==0)
+            {
+                if(iter+1 <= nbInputArguments  && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &filterSize);
+                    if(intErr)
+                    {
+                        return intErr;
+                    }
+                    providedArgs[1] = 1;
+                    if(filterSize!=1 && filterSize!=3 && filterSize!=5 && filterSize!=7)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are {1, 3, 5, 7}.\n", currentArg);
+                        return 0;
+                    }
+                }
+                else if(providedArgs[1])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n");
+                    return 0;
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n");
+                    return 0;
+                }
+            }
+            else if(strcmp(currentArg, "ROI")==0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+                    {
+                        Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter);
+                        return 0;
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &matrixOfRoi);
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    if(iRows!=1 || iCols!=4)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument ROI.\n");
+                        return 0;
+                    }
+                    providedArgs[2] = 1;
+                    if(matrixOfRoi[0] < 0 || matrixOfRoi[0] > sourceImage.cols || matrixOfRoi[1] < 0 ||
+                        matrixOfRoi[1] > sourceImage.rows || matrixOfRoi[2] < 0 || matrixOfRoi[0] + matrixOfRoi[2] > sourceImage.cols
+                        || matrixOfRoi[3] < 0 || matrixOfRoi[1] + matrixOfRoi[3] > sourceImage.rows)
+                    {
+                        Scierror(999, "Error: Please provide proper values for \"%s\".\n", currentArg);
+                        return 0;
+                    }
+                }
+                else if(providedArgs[2])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n");
+                    return 0;
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n");
+                    return 0;
+                }
+            }
+            else if(strcmp(currentArg, "SensitivityFactor")==0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[3])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &sensitivityFactor);
+                    if(intErr)
+                    {
+                        return intErr;
+                    }
+                    providedArgs[3] = 1;
+                    if(sensitivityFactor < 0 || sensitivityFactor > 0.25)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are [0, 0.25].\n", currentArg);
+                        return 0;
+                    }
+                }
+                else if(providedArgs[3])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n");
+                    return 0;
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n");
+                    return 0;
+                }
+            }
+            else
+            {
+                Scierror(999, "Error: \"%s\" name for input argument is not valid.\n", currentArg);
+                return 0;
+            }
+        }
+
+        //------Actual processing------//
+        cornerHarris(sourceImage(Rect(matrixOfRoi[0], matrixOfRoi[1], matrixOfRoi[2], matrixOfRoi[3])), dst, blockSize, filterSize, sensitivityFactor, BORDER_DEFAULT);
+
+        // Finding the maximum value at a pixel in dst
+        maxDst = 0;
+        for(int rowIter=0; rowIter < dst.rows; rowIter++)
+        {
+            for(int colIter=0; colIter < dst.cols; colIter++)
+            {
+                if(dst.at<float>(rowIter, colIter) > maxDst)
+                {
+                    maxDst = dst.at<float>(rowIter, colIter);
+                }
+            }
+        }
+
+        /* First, we threshold dst according to the minQuality expected by the user.
+           We then find contours in the thresholded image and check each pixel's value
+           to compute the local maxima. A extended mat is created because contours
+           having edges on the boundaries of the images are not considered by
+           findContours                                                                */
+        threshold(dst, dstThresholded, maxDst*minQuality, 255, THRESH_BINARY);
+        dstThresholded.convertTo(ucharDstThresholded, CV_8UC1);
+        extended = Mat(dst.rows+2, dst.cols+2, CV_8UC1);
+        for(int rowIter = 0; rowIter < extended.rows; rowIter++)
+        {
+            for(int colIter = 0; colIter < extended.cols; colIter++)
+            {
+                if(rowIter == 0 || rowIter == extended.rows - 1
+                || colIter == 0 || colIter == extended.cols - 1)
+                {
+                    extended.at<uchar>(rowIter, colIter) = 0;
+                }
+                else
+                {
+                    extended.at<uchar>(rowIter, colIter) = ucharDstThresholded.at<uchar>(rowIter-1, colIter-1);
+                }
+            }
+        }
+
+        findContours(extended, contours, CV_RETR_TREE, CV_CHAIN_APPROX_NONE);
+        pointCount = contours.size();
+        location = (int*) malloc(sizeof(int) * pointCount * 2);
+        metric = (double*) malloc(sizeof(double)*pointCount);
+        for(int rowIter = 0; rowIter < contours.size(); rowIter++)
+        {
+            localMax = 0;
+            localMaxPos = 0;
+            for(int colIter=0; colIter<contours[rowIter].size(); colIter++)
+            {
+                if(dst.at<float>(contours[rowIter][colIter].y-1, contours[rowIter][colIter].x-1)>localMax)
+                {
+                    localMax = dst.at<float>(contours[rowIter][colIter].y-1, contours[rowIter][colIter].x-1);
+                    localMaxPos = colIter;
+                }
+            }
+            if(localMax > maxDst*minQuality)
+            {
+                location[rowIter] = contours[rowIter][localMaxPos].x-1 + matrixOfRoi[0];
+                location[pointCount + rowIter] = contours[rowIter][localMaxPos].y-1 + matrixOfRoi[1];
+                metric[rowIter] = dst.at<float>(location[pointCount + rowIter], location[rowIter]);
+            }
+        }
+
+        // To return coordinates in order
+        for(int iter1 = 0; iter1 < pointCount - 1; iter1++)
+        {
+            coordinateMin = location[iter1];
+            coordinatePos = iter1;
+            for(int iter2 = iter1 + 1; iter2 < pointCount; iter2++)
+            {
+                if(location[iter2] < coordinateMin)
+                {
+                        coordinateMin = location[iter2];
+                        coordinatePos = iter2;
+                }
+                else if(location[iter2] == coordinateMin)
+                {
+                    if(location[pointCount + iter2] < location[pointCount + coordinatePos])
+                    {
+                        coordinateMin = location[iter2];
+                        coordinatePos = iter2;
+                    }
+                }
+            }
+            // Swapping x coordinate
+            tempForSwapping = location[coordinatePos];
+            location[coordinatePos] = location[iter1];
+            location[iter1] = tempForSwapping;
+            // Swapping y coordinate
+            tempForSwapping = location[pointCount + coordinatePos];
+            location[pointCount + coordinatePos] = location[pointCount + iter1];
+            location[pointCount + iter1] = tempForSwapping;
+            // Swapping metric
+            tempForSwapping = metric[coordinatePos];
+            metric[coordinatePos] = metric[iter1];
+            metric[iter1] = tempForSwapping;
+        }
+
+        //------Create output arguments------//
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+1, pointCount, 2, location);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+2, pointCount, 1, metric);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+3, 1, 1, &pointCount);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2;
+        AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_detectMSERFeatures.cpp b/sci_gateway1/cpp/opencv_detectMSERFeatures.cpp
new file mode 100644
index 0000000..a437c16
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectMSERFeatures.cpp
@@ -0,0 +1,451 @@
+/********************************************************************************************************************************************************************************************************
+*	Author:	Umang Agrawal																					        *
+*	Code:	detectMSERFeatures.cpp																				        *
+*	Function Format:	[ list_pixels, ......] = detectMSERFeatures( image, Optional Arguments........)											        *
+*					Input Arguments:	1. Image (Grayscale or RGB)													        *
+*								2. ThresholdDelta	Value: 	(0:100] Expressed in Percentage										*
+*								3. RegionAreaRange	Value:	[ Min_Area , Max_Area ]											*
+*								4. MaxAreaVariation	Value:	Scalar Double typical range from 0.25 - 4								*
+*								5. ROI			Value: 	[ x_cord , y_cord , width , height ] 									*
+*																									*
+*					Output Argument:	1. List Of Pixels stating the Locus of all features detected										*
+*								2. Count 																*
+*								3. Location: Centroid of each Locus													*
+*								4. Axes: Major and Minor axis length of ellipse												*
+*								5. Orientation: Tilt of the elliptical fit												*
+*																									*
+********************************************************************************************************************************************************************************************************/
+
+
+#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"
+
+	int opencv_detectMSERFeatures(char *fname, unsigned long fname_len)
+	{
+		//Various Declarations
+		//Error Variables		
+		SciErr sciErr;
+		int sca_read;
+
+		//Mat containers for image
+		Mat image;
+		Mat cropped;
+
+		//Address of Various Arguments
+		int *piAddr = NULL;
+		int *piAddr2 = NULL;
+		int *piAddr3 = NULL;
+
+		int inp_params, out_params;							//Count of Parameters
+		double arg_val;									//Memory for Scalar Argument Value
+		int Rows, Cols;									//Rows and Columns for Matrix Argument Value
+		double *roi_arg = NULL;								//Memory for Matrix Argument Value
+		int *pilen = NULL;								//For String Matrix Reading: Length of String
+		char **arg = NULL;								//For String Matrix Reading: String
+		int count_area = 0, count_tres = 0, count_var = 0, count_roi = 0;		//Count of all the optional Arguments
+		double x = 0, y = 0, width = 0, height = 0;					//Initials of all Cropped Varaibles
+
+		int i,j;									//Iterator
+
+		int delta = 5, min_area = 60, max_area = 14400, max_evolution = 200, edge_blur_size = 5;		//Arguments of MSER function with default values
+		double max_variation = 0.25, min_diversity = 0.2, area_threshold = 1.01, min_margin = 0.003;		//Arguments of MSER function with default values
+
+		double *pixellist = NULL;							//Output Argument Pixellist
+		int count[1] ;									//Output Argument Count
+		double *location = NULL;							//Output Argument Location
+		double *axes = NULL;								//Output Argument Axes
+		double *orientation = NULL;							//Output Argument Orientation
+
+		vector< vector<Point> > mser_points;						//3D vector for storing the locus of each detected feature
+		vector< RotatedRect > regions;							//RotatedRect vector for storing each region associated with a feature
+
+		CheckInputArgument(pvApiCtx, 1, 9);						//Check on Number of Input Arguments
+		CheckOutputArgument(pvApiCtx, 1, 5);						//Check on Number of Output Arguments
+
+		//Read Image
+		retrieveImage(image, 1);							
+		
+		//Getting Number of Input Arguments
+		inp_params = *getNbInputArgument(pvApiCtx);
+
+		//Based on the number of Input Arguments, alter the arguments of the MSER funtion.
+		for(i=2; i<=inp_params; i++)
+		{
+			if( inp_params == 2 || inp_params == 4 || inp_params == 6 || inp_params == 8)
+			{
+				Scierror(999,"Either Argument Name or its Value missing\n");
+				return 0;
+			}
+			//Reading the Name of the Argument
+			sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddr2);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			//Check for Argument type
+			if( !isStringType(pvApiCtx, piAddr2))
+			{
+				Scierror(999, "%s: Wrong type of argument #%d. A string is expected.\n", fname, 1);
+				return 0;
+			}
+			//Matrix of Stings
+			sciErr = getMatrixOfString(pvApiCtx, piAddr2, &Rows, &Cols, NULL, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			pilen = (int*)malloc(sizeof(int) * Rows * Cols);
+			//second call to retrieve the length of the string
+			sciErr = getMatrixOfString(pvApiCtx, piAddr2, &Rows, &Cols, pilen, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(pilen);
+				return 0;
+			}
+			arg = (char**)malloc(sizeof(char*) * Rows * Cols);
+			for(int j=0;j< Rows * Cols; j++)
+			{
+				arg[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+			}
+
+			//third call to retrieve data
+			sciErr = getMatrixOfString(pvApiCtx, piAddr2, &Rows, &Cols, pilen, arg);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(pilen);
+				free(arg);
+				return 0;
+			}
+
+			if(strcmp(arg[0],"ThresholdDelta") == 0)
+			{
+				if(count_tres == 0)
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr3);
+					if(sciErr.iErr)
+					{
+					printError(&sciErr, 0);
+					return 0;
+					}
+					//Checking the type of value
+					if( !isDoubleType(pvApiCtx, piAddr3))
+					{
+						Scierror(999,"Not a valid type of value.\n");
+						return 0;
+					}
+					//Reading the Value of the argument
+					sca_read = getScalarDouble(pvApiCtx, piAddr3, &arg_val);
+					if(sca_read)
+					{
+						Scierror(999,"Not a valid value.\n");
+						return 0;
+					}
+					//Check for valid range
+					if(arg_val <= 0 && arg_val > 100)
+					{
+					Scierror(999,"Not a valid range.Should be between 0 and 100.\n");
+					return 0;
+					}
+					delta = arg_val;
+					i++;
+					count_tres += 1;
+				}
+				else
+				{
+					Scierror(999,"ThresholdDelta has been specified twice.Check the Arguments\n");
+					return 0;
+				}
+			}
+			else if(strcmp(arg[0],"RegionAreaRange") == 0)
+			{
+				if(count_area == 0)
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr3);
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0);
+						return 0;
+					}
+					//Checking the type of argument
+					if( !(isDoubleType(pvApiCtx, piAddr3) || isIntegerType(pvApiCtx, piAddr3)) )
+					{
+						Scierror(999,"Not a valid type of value.\n");
+						return 0;					
+					}
+					//Reading the Value of the argument
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &Rows, &Cols, &roi_arg);
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0);
+						return 0;
+					}
+					if( Rows*Cols != 2 )
+					{
+						Scierror(999,"Only 2 values are expected.Neither less nor more\n");
+						return 0;
+					} 
+					if( roi_arg[0] >= roi_arg[1] )
+					{
+						Scierror(999,"Max Area should be greater than Min Area\n");
+						return 0;
+					}	
+					//Assigning the elements of the list to their proper function				
+					min_area = roi_arg[0];
+					max_area = roi_arg[1];
+					i++;
+					count_area += 1;
+				}
+				else
+				{
+				Scierror(999,"RegionAreaRange has been specified twice.Check the Arguments\n");
+                                return 0;
+				}
+			}
+			else if(strcmp(arg[0],"MaxAreaVariation") == 0)
+			{
+				if(count_var == 0)
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr3);
+                                        if(sciErr.iErr)
+                                        {
+                                        printError(&sciErr, 0);
+                                        return 0;
+                                        }
+                                        //Checking the type of value
+                                        if( !isDoubleType(pvApiCtx, piAddr3))
+                                        {
+                                                Scierror(999,"Not a valid type of value.\n");
+                                                return 0;
+                                        }
+                                        //Reading the Value of the argument
+                                        sca_read = getScalarDouble(pvApiCtx, piAddr3, &arg_val);
+                                        if(sca_read)
+                                        {
+                                                Scierror(999,"Not a valid value.\n");
+                                                return 0;
+                                     	}
+                                        max_variation = arg_val;
+                                  	i++;
+					count_var += 1;
+				}
+				else
+				{
+					Scierror(999,"MaxAreaVariation has been specified twice.Check the Arguments\n");
+                                        return 0;
+				}
+			}
+			else if(strcmp(arg[0],"ROI") == 0)
+			{
+				if(count_roi == 0)
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr3);
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0);
+						return 0;
+					}
+					//Checking the type of argument
+					if( !(isDoubleType(pvApiCtx, piAddr3) || isIntegerType(pvApiCtx, piAddr3)) )
+					{
+						Scierror(999,"Not a valid type of value.\n");
+						return 0;
+					}
+					//Reading the Value of the argument
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &Rows, &Cols, &roi_arg);
+					if(sciErr.iErr)
+					{
+					printError(&sciErr, 0);
+					return 0;
+					}
+					if( Rows*Cols != 4 )
+					{
+						Scierror(999,"Expected 4 arguments in format [x,y,width,height]\n");
+						return 0;
+					}
+					//Assigning the elements of the list to their proper function
+					x = roi_arg[0];
+					y = roi_arg[1];
+					width = roi_arg[2];
+					height = roi_arg[3];
+					if(x>=image.cols || y>=image.rows || x<0 || y<0)
+   			 		{
+        					sciprint("Invalid x or y value\n");
+        					return 0;
+    					}
+    					if(width<=0 || height<=0 || x+width > image.cols || y+height > image.rows)
+    					{
+        					sciprint("Invalid width or height value\n");
+        					return 0;
+    					}
+					Rect myROI(x, y, width, height);
+					Mat croppedRef(image, myROI);
+					croppedRef.copyTo(cropped);
+					i++;						//Incrementing iterator to count for the value argument read
+					count_roi += 1;					//Indicating ROI has been called once
+				}
+				else
+				{
+					Scierror(999,"ROI has been specified twice.Check the Arguments\n");
+                                        return 0;
+				}
+			}
+			else
+			{
+				Scierror(999,"Invalid Argument\n");
+				return 0;
+			}
+		}
+
+		//Creating an MSER class Object with specified conditions
+		MSER img_ms = MSER(delta, min_area, max_area, max_variation, min_diversity, max_evolution, area_threshold, min_margin, edge_blur_size);
+		
+		//Checking if have to operate on original image or cropped one
+		// 1st Argument: Image on which MSER features has to be detected
+		// 2nd Argument: Locus of all the points detected
+		// 3rd Argument: Mask of empty Mat container
+		if(count_roi == 0)
+			img_ms( image, mser_points, Mat());
+		else
+			img_ms( cropped, mser_points, Mat());
+
+		// Extracting Regions from the mser_points locus and approximating them to an elliptic fit
+		for(i=0; i<mser_points.size(); i++)
+			regions.push_back(fitEllipse(mser_points[i]));
+
+		//Memory Allocation for all the output parameters		
+		location = (double *)malloc(sizeof(double) * mser_points.size() * 2);
+		axes = (double *)malloc(sizeof(double) * mser_points.size() * 2);
+		orientation = (double *)malloc(sizeof(double) * mser_points.size());
+
+		//Output Arguments: Pixel_list, Count, Location, Axes, Orientation		
+		count[0] = mser_points.size();								//Count
+		for(i=0; i<mser_points.size(); i++)
+		{
+			location[i] = regions[i].center.x + x;						//Location X co-ordinate
+			location[mser_points.size() + i] = regions[i].center.y + y;				//Location Y co-ordinate
+			if( regions[i].size.width >= regions[i].size.height )
+			{
+				axes[i] = regions[i].size.width;					//Axis: Major Axis of Ellipse
+				axes[mser_points.size() + i] = regions[i].size.height;			//Axis: Minor Axis of Ellipse
+			}
+			else
+			{
+				axes[i] = regions[i].size.height;					//Axis: Major Axis of Ellipse
+				axes[mser_points.size() + i] = regions[i].size.width;			//Axis: Minor Axis of Ellipse
+			}
+			orientation[i] = regions[i].angle;						//Orientation
+		}
+
+		//Reading the number of output Arguments user demands
+		
+		//Assigning Pixel_List
+		out_params = *getNbOutputArgument(pvApiCtx);
+		if( out_params >= 1 )
+		{
+			sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, mser_points.size(), &piAddr);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			for(i = 0; i<mser_points.size(); i++)
+			{
+				pixellist = (double *)malloc(sizeof(double) * mser_points[i].size() * 2);
+				for( j=0; j<mser_points[i].size(); j++)
+				{
+					pixellist[j] = mser_points[i][j].x + x;
+					pixellist[mser_points[i].size() + j] = mser_points[i][j].y + y;
+				}
+				sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, i+1, mser_points[i].size(), 2, pixellist);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				free(pixellist);
+			}
+			AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		}
+		
+		//Assigning Count
+		if( out_params >= 2 )
+		{
+			sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 1, count);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+		}
+	
+		//Assigning Location
+		if( out_params >= 3 )
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, mser_points.size(), 2, location);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+		}
+
+		//Assigning Axes
+		if( out_params >= 4 )
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 4, mser_points.size(), 2, axes);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+		}
+
+		//Assigning Orientation
+		if( out_params == 5 )
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, mser_points.size(), 1, orientation);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+		}
+
+		//Releasing all the memory Captured
+		free(location);
+		free(axes);
+		free(orientation);
+
+		//Returning the Output Arguments
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
diff --git a/sci_gateway1/cpp/opencv_detectMinEigenFeatures.cpp b/sci_gateway1/cpp/opencv_detectMinEigenFeatures.cpp
new file mode 100644
index 0000000..5138185
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectMinEigenFeatures.cpp
@@ -0,0 +1,366 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <math.h>
+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"
+    
+    /* Calling syntax: detectMinEigenFeatures(I) or detectMinEigenFeatures(I, Name, Value)   
+       which uses additional options specified by one or more Name, Value pair arguments.             
+       Arguments Allowed: MinQuality, FilterSize, ROI
+       MinQuality        : The minimum accepted quality of corners represents a fraction of the
+                           maximum corner metric value in the image. Larger values can be used 
+                           to remove erroneous corners.
+       FilterSize        : Gaussian filter dimension
+       ROI               : Rectangular region for corner detection                                    */
+
+    int opencv_detectMinEigenFeatures(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr; 
+        int intErr; 
+        
+        //------Local variables------//        
+        int *location = NULL; 
+        double *metric = NULL; 
+        int *piAddr = NULL;       
+        int *piLen = NULL; 
+        int nbInputArguments; 
+        char **pstData = NULL; 
+        char *currentArg = NULL; 
+        bool *providedArgs = NULL; 
+        double *matrixOfRoi;  // ROI[xStart, yStart, width, height]
+        int iRows, iCols; 
+        Mat sourceImage, dst, dstThresholded, ucharDstThresholded, extended; 
+        vector<vector<Point> > contours; 
+        double filterSize = 5, minQuality = 0.01, blockSize = 2, maxDst, localMax; 
+        bool *included = NULL; 
+        int pointCount = 0, localMaxPos; 
+        double tempForSwapping;
+        int coordinateMin, coordinatePos;
+        
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 1, 7); 
+        CheckOutputArgument(pvApiCtx, 1, 3); 
+        
+        //------Get input arguments------//
+        retrieveImage(sourceImage, 1); 
+        if(sourceImage.channels() != 1)
+        {
+            Scierror(999, "The input image is not a grayscale image."); 
+            return 0; 
+        }
+        matrixOfRoi = (double*) malloc(sizeof(double) * 4); 
+        providedArgs = (bool*) malloc(sizeof(bool) * 3); 
+        memset(providedArgs, 0, 3); 
+        matrixOfRoi[0] = 0; 
+        matrixOfRoi[1] = 0; 
+        matrixOfRoi[2] = sourceImage.cols; 
+        matrixOfRoi[3] = sourceImage.rows; 
+        nbInputArguments = *getNbInputArgument(pvApiCtx); 
+        
+        // The following loop is for checking if optional arguments have been provided
+        for(int iter=2; iter <= nbInputArguments; iter++)
+        {
+            // Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            // Extracting name of next argument takes three calls to getMatrixOfString
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+            
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+            
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            currentArg = pstData[0]; 
+            // providedArgs[] makes sure that no optional argument is provided more than once
+            if(strcmp(currentArg, "MinQuality")==0)
+            {
+                if(iter+1<=nbInputArguments && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &minQuality); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    // Checking if values are in proper range. Same for all optional arguments
+                    if(minQuality < 0 || minQuality > 1)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible range is [0, 1].\n", currentArg); 
+                        return 0; 
+                    }
+                    providedArgs[0] = 1; 
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "FilterSize")==0)
+            {
+                if(iter+1 <= nbInputArguments  && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &filterSize); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    providedArgs[1] = 1; 
+                    if(filterSize!=1 && filterSize!=3 && filterSize!=5 && filterSize!=7)
+                    {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are {1, 3, 5, 7}.\n", currentArg); 
+                        return 0; 
+                    }
+                }
+                else if(providedArgs[1])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "ROI")==0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+                    {
+                        Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &matrixOfRoi); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows!=1 || iCols!=4)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument ROI.\n"); 
+                        return 0; 
+                    }
+                    providedArgs[2] = 1; 
+                    if(matrixOfRoi[0] < 0 || matrixOfRoi[0] > sourceImage.cols || matrixOfRoi[1] < 0 ||
+                        matrixOfRoi[1] > sourceImage.cols || matrixOfRoi[2] < 0 || matrixOfRoi[0] + matrixOfRoi[2] > sourceImage.cols
+                        || matrixOfRoi[3] < 0 || matrixOfRoi[1] + matrixOfRoi[3] > sourceImage.rows)
+                    {
+                        Scierror(999, "Error: Please provide proper values for \"%s\".\n", currentArg); 
+                        return 0; 
+                    }
+                }
+                else if(providedArgs[2])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else
+            {
+                Scierror(999, "Error: \"%s\" name for input argument is not valid.\n", currentArg); 
+                return 0; 
+            }
+        }
+        
+        //------Actual processing------//
+        cornerMinEigenVal(sourceImage(Rect(matrixOfRoi[0], matrixOfRoi[1], matrixOfRoi[2], matrixOfRoi[3])), dst, blockSize, filterSize, BORDER_DEFAULT); 
+        
+        // Finding the maximum value at a pixel in dst        
+        maxDst = 0; 
+        for(int rowIter=0; rowIter < dst.rows; rowIter++)
+        {
+            for(int colIter=0; colIter < dst.cols; colIter++)
+            {
+                if(dst.at<float>(rowIter, colIter) > maxDst)
+                {
+                    maxDst = dst.at<float>(rowIter, colIter); 
+                }
+            }
+        }
+        
+        /* First, we threshold dst according to the minQuality expected by the user.
+           We then find contours in the thresholded image and check each pixel's value
+           to compute the local maxima. A extended mat is created because contours 
+           having edges on the boundaries of the images are not considered by 
+           findContours                                                                */
+        threshold(dst, dstThresholded, maxDst*minQuality, 255, THRESH_BINARY); 
+        dstThresholded.convertTo(ucharDstThresholded, CV_8UC1); 
+        extended = Mat(dst.rows+2, dst.cols+2, CV_8UC1); 
+        for(int rowIter = 0; rowIter < extended.rows; rowIter++)
+        {
+            for(int colIter = 0; colIter < extended.cols; colIter++)
+            {
+                if(rowIter == 0 || rowIter == extended.rows - 1
+                || colIter == 0 || colIter == extended.cols - 1)
+                {
+                    extended.at<uchar>(rowIter, colIter) = 0; 
+                }
+                else
+                {
+                    extended.at<uchar>(rowIter, colIter) = ucharDstThresholded.at<uchar>(rowIter-1, colIter-1); 
+                }
+            }
+        }
+        
+        findContours(extended, contours, CV_RETR_TREE, CV_CHAIN_APPROX_NONE); 
+        pointCount = contours.size(); 
+        location = (int*) malloc(sizeof(int) * pointCount * 2); 
+        metric = (double*) malloc(sizeof(double)*pointCount); 
+        for(int rowIter = 0; rowIter < contours.size(); rowIter++)
+        {
+            localMax = 0; 
+            localMaxPos = 0; 
+            for(int colIter=0; colIter<contours[rowIter].size(); colIter++)
+            {
+                if(dst.at<float>(contours[rowIter][colIter].y-1, contours[rowIter][colIter].x-1)>localMax)
+                {
+                    localMax = dst.at<float>(contours[rowIter][colIter].y-1, contours[rowIter][colIter].x-1); 
+                    localMaxPos = colIter; 
+                }
+            }
+            if(localMax > maxDst*minQuality)
+            {
+                location[rowIter] = contours[rowIter][localMaxPos].x-1 + matrixOfRoi[0]; 
+                location[pointCount + rowIter] = contours[rowIter][localMaxPos].y-1 + matrixOfRoi[1]; 
+                metric[rowIter] = dst.at<float>(location[pointCount + rowIter], location[rowIter]); 
+            }
+        }
+        
+        // To return coordinates in order
+        for(int iter1 = 0; iter1 < pointCount - 1; iter1++)
+        {
+            coordinateMin = location[iter1];
+            coordinatePos = iter1;
+            for(int iter2 = iter1 + 1; iter2 < pointCount; iter2++)
+            {
+                if(location[iter2] < coordinateMin)
+                {
+                        coordinateMin = location[iter2];
+                        coordinatePos = iter2;
+                }
+                else if(location[iter2] == coordinateMin)
+                {
+                    if(location[pointCount + iter2] < location[pointCount + coordinatePos])
+                    {
+                        coordinateMin = location[iter2];
+                        coordinatePos = iter2;
+                    }
+                }
+            }
+            // Swapping x coordinate
+            tempForSwapping = location[coordinatePos];
+            location[coordinatePos] = location[iter1];
+            location[iter1] = tempForSwapping; 
+            // Swapping y coordinate
+            tempForSwapping = location[pointCount + coordinatePos];
+            location[pointCount + coordinatePos] = location[pointCount + iter1];
+            location[pointCount + iter1] = tempForSwapping; 
+            // Swapping metric
+            tempForSwapping = metric[coordinatePos];
+            metric[coordinatePos] = metric[iter1];
+            metric[iter1] = tempForSwapping; 
+        }
+        //------Create output arguments------//
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+1, pointCount, 2, location); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+2, pointCount, 1, metric); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx)+3, 1, 1, &pointCount); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1; 
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2; 
+        AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3; 
+        ReturnArguments(pvApiCtx); 
+        return 0; 
+    }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_detectSURFFeatures.cpp b/sci_gateway1/cpp/opencv_detectSURFFeatures.cpp
new file mode 100644
index 0000000..8a62361
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_detectSURFFeatures.cpp
@@ -0,0 +1,432 @@
+/***************************************************
+Author : Shashank Shekhar
+***************************************************/
+
+#include <numeric>
+#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/opencv.hpp"
+#include <iostream>
+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"
+    //#include "../common.cpp"
+
+int opencv_detectSURFFeatures(char *fname, unsigned long fname_len)
+{
+    
+    SciErr sciErr;
+
+
+    int *piAddr = NULL;
+    int *piAddrVal = NULL;
+    int val_position;
+    int *piLen = NULL;
+    int iRows, iCols = 0;
+    char ** pstData = NULL;
+    char *currentArg = NULL;
+    int valOfCA;
+    int argPresence[4];
+    for(int i=0;i<4;i++)
+        argPresence[i]=0;
+
+    vector<KeyPoint> myPoints;
+
+    int *LocationList = NULL;
+    int *OrientationList = NULL;
+    int *MetricList = NULL;
+    int *LaplacianList = NULL;
+    int *ScaleList = NULL;
+
+    double *LocationData = NULL;
+    double *OrientationData = NULL;
+    double *MetricData = NULL;
+    int *LaplacianData = NULL;	
+    double *ScaleData = NULL;
+
+    int noOfarguments = *getNbInputArgument(pvApiCtx);
+
+        CheckInputArgument(pvApiCtx, 1,9);
+        CheckOutputArgument(pvApiCtx,1,6);    
+
+    Mat image;
+    retrieveImage(image,1);
+
+
+    if(image.channels()!=1)
+    {
+        Scierror(999," Feature is not meant for RGB images\n");
+        return 0;        
+    }
+
+//********************************************* Valid Argument Count Check *****************************************
+
+    if(noOfarguments%2==0)
+    {
+        Scierror(999," Invalid No of Arguments \n");
+        return 0;
+    } 
+
+//*********************************************  Optional Input Arguments  ***************************************** 
+
+    double MetricThreshold = 0;
+    double NumOctaves = 0;
+    double NumScaleLevels = 0;
+    double *ROImat = NULL;
+
+//*********************************************  Retrieval of Name, Value Argument Pair ****************************
+
+
+    for(int i=2;i<=noOfarguments;i=i+2)
+    {
+        sciErr = getVarAddressFromPosition(pvApiCtx,i,&piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(!isStringType(pvApiCtx, piAddr))
+        {
+            Scierror(999,"Invalid Argument\n");
+            return 0;
+        }
+
+        //first call to get rows and columns 
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+        
+//second call to retrieve length of each string
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+        for(int j = 0 ; j < iRows * iCols ; j++)
+        {
+            pstData[j] = (char*)malloc(sizeof(char) * (piLen[j] + 1));//+ 1 for null termination
+        }   
+//third call to retrieve data
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        currentArg = pstData[0];
+        free(pstData);
+        iRows=0;
+        iCols=0;
+        free(piLen);
+
+        if(strcmp(currentArg,"MetricThreshold")==0)
+        {
+
+            val_position=i+1;  
+            
+            if(argPresence[0]==1)
+            {
+                Scierror(999,"Do not enter the same parameter\n");
+                return 0;
+            }
+	
+            sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;   
+            }
+
+            if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+            {
+                Scierror(999," Invalid Value for MetricThreshold. Please enter a non negative Double value\\n");
+                return 0;
+    	    }
+				
+       	    getScalarDouble(pvApiCtx, piAddrVal, &MetricThreshold);
+                  
+            if(MetricThreshold<0)
+            {
+                Scierror(999," Invalid Value for MetricThreshold. Please enter a non negative Double value\\n");
+                return 0;
+            }                
+            argPresence[0]=1;       
+        }
+        else if(strcmp(currentArg,"NumOctaves")==0)
+        {
+            val_position=i+1;           
+
+            if(argPresence[1]==1)
+            {
+                Scierror(999,"Do not enter the same parameter\n");
+                return 0;
+            }
+
+
+            sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+	        if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+            {
+	
+                Scierror(999," Invalid Value for NumOctaves. Recommended Values are between 1 and 4\n");
+                return 0;
+	        }       
+             
+	        getScalarDouble(pvApiCtx, piAddrVal, &NumOctaves);
+                
+            if(NumOctaves<1)
+            {
+                Scierror(999," Invalid Value for NumOctaves. Recommended Values are between 1 and 4\n");
+                return 0;
+            }   
+
+            argPresence[1]=1;     
+        }
+        else if(strcmp(currentArg,"NumScaleLevels")==0)
+        {
+            val_position=i+1; 
+            
+            if(argPresence[2]==1)
+            {
+                Scierror(999,"Do not enter the same parameter\n");
+                return 0;
+            }
+
+            sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+    	    if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx,piAddrVal) || !isScalar(pvApiCtx, piAddrVal))
+            {
+	            Scierror(999," Invalid Value for NumScaleLevels. Recommended values are between 3 and 6\n");
+                return 0;
+	        }   
+    
+            getScalarDouble(pvApiCtx, piAddrVal, &NumScaleLevels);
+                
+            if(NumScaleLevels<3)
+            {
+                Scierror(999," Invalid Value for NumScaleLevels. Please enter an integer value greater than or equal to 3\n");
+                return 0;
+            }
+  
+            argPresence[2]=1; 
+        }
+        else if(strcmp(currentArg,"ROI")==0)
+        {
+            val_position=i+1;          
+
+            if(argPresence[3]==1)
+            {
+                Scierror(999,"Do not enter the same parameter\n");
+                return 0;
+            }
+            
+            sciErr = getVarAddressFromPosition(pvApiCtx,val_position,&piAddrVal);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            if(!isDoubleType(pvApiCtx, piAddrVal) || isVarComplex(pvApiCtx, piAddrVal))
+            {
+                Scierror(999,"Enter a List of 4 double arguments\n");
+                return 0;
+            }
+
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrVal, &iRows, &iCols, &ROImat);  
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            if(iRows*iCols!=4)
+            {   
+                Scierror(999,"Invalid Argument\n");
+                return 0;
+            }
+
+
+            if(ROImat[0]<0 || ROImat[1]<0 || ROImat[2]<0 || ROImat[3]<0)
+            {   
+               sciprint("Arguments cannot be negative\n");
+                return 0;
+            }       
+
+            if(ROImat[0]>image.cols || ROImat[1]>image.rows || ROImat[0]+ROImat[2]>image.cols
+                || ROImat[1]+ROImat[3]>image.rows) 
+            {
+                Scierror(999,"Please make sure the arguments are within the image range\n");
+                return 0;
+            }
+
+            argPresence[3]=1;
+        }
+        else
+        {
+            Scierror(999, "Error: \"%s\" name for input argument is not valid.\n", currentArg); 
+            return 0; 
+        }
+
+    }
+//*********************************************  End of OIA  ********************************************************
+
+int nOctaveLayers;
+
+    if(argPresence[2]==1)
+	nOctaveLayers = NumScaleLevels-2;	
+
+
+    if(argPresence[0]==0)
+        MetricThreshold=1000;
+    if(argPresence[1]==0)
+        NumOctaves=3;
+    if(argPresence[2]==0)
+        nOctaveLayers = 2;
+    if(argPresence[3]==0)
+    {
+	ROImat=(double *)malloc(sizeof(double)*4);
+        ROImat[0]=0;
+        ROImat[1]=0;	
+        ROImat[2]=image.cols;
+        ROImat[3]=image.rows;       
+    }
+
+
+    Rect masker(ROImat[0], ROImat[1], ROImat[2], ROImat[3]);
+    
+	Mat mask(image.size(), CV_8UC1, Scalar::all(0));
+	mask(masker).setTo(Scalar::all(255));
+   
+
+
+    SURF my_object(MetricThreshold, NumOctaves, nOctaveLayers);
+
+    my_object.operator()(image, mask, myPoints, noArray());	
+
+    int size= myPoints.size();
+
+//*************************************************************** Location ***************************************************************
+
+	 ScaleData = (double *)malloc(sizeof(double)*size);
+	 OrientationData = (double *)malloc(sizeof(double)*size);
+  	 MetricData = (double *)malloc(sizeof(double)*size);
+ 	 LaplacianData = (int *)malloc(sizeof(int)*size);
+
+    iRows=size;
+    iCols=2;
+    int k=0;
+     
+    LocationData = (double *)malloc(sizeof(double)*iRows*iCols);
+
+    for(int i=0;i<size;i++)
+    {
+       
+        LocationData[k++] = myPoints[i].pt.x;
+        LocationData[k++] = myPoints[i].pt.y;
+	    OrientationData[i] = 0;
+	    MetricData[i] = myPoints[i].response;
+	    LaplacianData[i] = myPoints[i].class_id;
+	    double q=myPoints[i].size;                 
+//          Scale  =  Current Filter Size * Base Filter Scale / Base Filter Size
+        q = q*1.2/9;
+        q = round(1000.0*q)/(1000.0);
+        ScaleData[i] = q;
+     
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, size,2, LocationData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+//*************************************************************** Orientation ***************************************************************
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, size,1, OrientationData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; 
+        
+ //***********************************************************  Metric ********************************************************************   
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, size,1, MetricData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+ 
+//************************************************************  SignOfLaplacian ***********************************************************
+    
+    sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 4, size,1, LaplacianData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+//***********************************************************  Scale  *******************************************************************
+ 
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, size,1, ScaleData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+
+//***********************************************************  Size *********************************************************************
+      
+    createScalarInteger32(pvApiCtx,nbInputArgument(pvApiCtx) + 6, size);
+      
+    AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
+
+	
+    //Returning the Output Variables as arguments to the Scilab environment
+	
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_dilate.cpp b/sci_gateway1/cpp/opencv_dilate.cpp
new file mode 100644
index 0000000..44b26f1
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_dilate.cpp
@@ -0,0 +1,119 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <math.h>
+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"
+  
+  int opencv_dilate(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    char **type = NULL;
+    int i,j,k;
+    double anchorX,anchorY,iterations;
+    double *kernel = NULL;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for kernel
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &kernel);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr,0);
+        return 0;
+    }
+
+    double actualkernel[iRows][iCols];
+    for(i=0;i<iRows;i++)
+        for(j=0;j<iCols;j++)
+            actualkernel[i][j]=kernel[(j*iRows)+i];
+        
+    Mat kernelMatrix(iRows,iCols,CV_64F,&actualkernel);
+
+    //for value of anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&anchorX);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4 ,&anchorY);
+    if(intErr)
+        return intErr;
+
+    //for value of iterations
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&iterations);
+    if(intErr)
+        return intErr;
+
+    Mat new_image(image.rows,image.cols,image.type());
+    Point pt(anchorX,anchorY);
+
+    dilate(image,new_image,kernelMatrix,pt,iterations);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_ellipse.cpp b/sci_gateway1/cpp/opencv_ellipse.cpp
new file mode 100644
index 0000000..092ab78
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_ellipse.cpp
@@ -0,0 +1,278 @@
+/********************************************************
+    Author: Sukul Bagai
+*********************************************************
+   return_image = ellipse(input_image , x_coordinate_of_centre , y_coordinate_centre , first_axis, second_axis, angle, startAngle, endAngle, r_value,g_value,b_value,thickness,linetype,shift);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_ellipse(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10  = NULL;
+    int *piAddr11  = NULL;
+    int *piAddr12  = NULL;
+    int *piAddr13  = NULL;
+    int *piAddr14  = NULL;
+    int i,j,k;
+    double thickness=1 , linetype=8, shift=0 ,centre_x ,centre_y,first_axis,second_axis,angle,startAngle,endAngle,r_value,g_value,b_value;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 14, 14);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+   
+    //for value of x coordinate of centre
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&centre_x);
+    if(intErr)
+        return intErr;
+   
+
+    //for value of y coordinate of centre
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&centre_y);
+     if(intErr)
+        return intErr;
+
+    //for value of first_axis
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&first_axis);
+   if(intErr)
+        return intErr;
+
+    //for value of second_axis
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5,&first_axis);
+   if(intErr)
+        return intErr;
+
+    //for value of angle
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6,&angle);
+   if(intErr)
+        return intErr;
+
+    //for value of startAngle
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7,&startAngle);
+   if(intErr)
+        return intErr;
+
+    //for value of endAngle
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8,&endAngle);
+   if(intErr)
+        return intErr;
+
+    //for value of R value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,9,&piAddr9);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr9 ,&r_value);
+    if(intErr)
+        return intErr;
+
+      //for value of G value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,10,&piAddr10);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr10 ,&g_value);
+     if(intErr)
+        return intErr;
+
+    // for B value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,11,&piAddr11);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr11,&b_value);
+     if(intErr)
+        return intErr;
+
+    // for thickness of circle  default: 1
+    sciErr = getVarAddressFromPosition(pvApiCtx,12,&piAddr12);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr12,&thickness);
+    if(intErr)
+        return intErr;
+
+      //for line type of circle default: 8 
+    sciErr = getVarAddressFromPosition(pvApiCtx,13,&piAddr13);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+  
+    intErr = getScalarDouble(pvApiCtx, piAddr13,&linetype);
+    if(intErr)
+        return intErr;
+
+ // for shift in circle default : 0
+     sciErr = getVarAddressFromPosition(pvApiCtx,14,&piAddr14);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr14,&shift);
+    if(intErr)
+        return intErr;
+   
+    // checking radius parameter 
+    if (first_axis < 0)
+    {
+        first_axis=3;
+        sciprint("first_axis should be positive , 3 value was used instead\n");
+    }
+    if (second_axis < 0)
+    {
+        second_axis=3;
+        sciprint("second_axis should be positive , 3 value was used instead\n");
+    }
+    if (first_axis < second_axis)
+    { 
+        double temp;
+        temp=first_axis;
+        first_axis=second_axis;
+        second_axis=temp;
+        sciprint("first_axis should be greater than second_axis. Values swapped.\n");
+    }
+    if(angle < 0 || angle > 360)
+    {
+      angle=45;
+      sciprint("Imvalid angle value used. Using 45 instead");
+    }
+    if(startAngle < 0 || startAngle > 360)
+    {
+      startAngle=45;
+      sciprint("Imvalid startAngle value used. Using 120 instead");
+    }
+    if(endAngle < 0 || endAngle > 360)
+    {
+      endAngle=45;
+      sciprint("Imvalid endAngle value used. Using 120 instead");
+    }
+    // checking the parmeters for correct values   
+    if( r_value <0 || r_value >255)
+     {
+          r_value=0;
+          sciprint(" r value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+     if( g_value <0 || g_value >255)
+     {
+          g_value=0;
+          sciprint("  g value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if( b_value <0 || b_value >255)
+     {
+          b_value=0;
+          sciprint(" b value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if ((linetype!=0) && (linetype!=4)&& (linetype!=8))
+    {
+             linetype=8;
+             sciprint("Only 0/4/8 allowed , using 8 instead\n");
+     }
+    //temporary pt variable, to use in function as centre
+    Point pt(centre_x,centre_y);
+    Size sz(first_axis,second_axis);
+      /// Draw the circles detected
+   
+    ellipse( src, pt, sz, angle, startAngle, endAngle, Scalar(r_value,g_value,b_value), thickness, linetype, shift);
+     
+//// sending the image
+    string tempstring = type2str(src.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,src,1);
+    free(checker);
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_ellipse2poly.cpp b/sci_gateway1/cpp/opencv_ellipse2poly.cpp
new file mode 100644
index 0000000..e7edef4
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_ellipse2poly.cpp
@@ -0,0 +1,171 @@
+/********************************************************
+    Author: Abhilasha Sancheti 
+*********************************************************
+   pts = ellipse2Poly(double center_x,double center_y,double width,double height,int angle, int arcStart, int arcEnd, int delta)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_ellipse2poly(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr1 = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    double *pstData = NULL;
+    int i,j,k ;
+    double center_x,center_y,width,height,arcstart,arcend,delta,angle;
+     
+   
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 8, 8);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+//// to retreive the value of x coordinate of center    
+
+     sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr1 ,&center_x);
+    if(intErr)
+      return intErr;
+     
+    
+    
+//// to retreive the value of y coordinate of center
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&center_y);
+    if(intErr)
+       return intErr;
+
+//// to retreive the value of width
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&width);
+    if(intErr)
+       return intErr;
+
+//// to retreive the value of height
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&height);
+    if(intErr)
+       return intErr;
+
+//// to retreive the value of angle parameter
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5,&angle);
+    if(intErr)
+       return intErr;
+
+//// to retreive the value of arcstart parameter
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6,&arcstart);
+    if(intErr)
+       return intErr;
+
+//// to retreive the value of arcend parameter
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7,&arcend);
+    if(intErr)
+       return intErr;
+
+//// to retreive the value of delta parameter
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8,&delta);
+    if(intErr)
+       return intErr;
+
+   
+    vector<Point> pts;
+    Point center(center_x,center_y);
+    Size axes(width,height);
+    ellipse2Poly(center, axes, angle,  arcstart, arcend,delta, pts);
+   
+    int row = pts.size();
+    double *cor = (double *)malloc(row*2*sizeof(double));
+    for (int i=0;i<row;i++)
+    {
+        *(cor + i*2 +0)=pts[i].x;
+     // cout<<pts[i].x<<" "<<pts[i].y;
+        *(cor + i*2 +1)=pts[i].y;
+    }
+    
+  sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, row, 2, cor);
+  if(sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return 0;
+  }
+    
+  
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_epipolarlines.cpp b/sci_gateway1/cpp/opencv_epipolarlines.cpp
new file mode 100644
index 0000000..369d7d8
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_epipolarlines.cpp
@@ -0,0 +1,321 @@
+/*********************************************************************************
+*Author : Kevin George
+*
+*-> To execute, epipolarlines(I1,I2)
+*   where I1.1 & I2 are images
+*
+* This will display the matched points and the epipolar lines.
+*********************************************************************************/
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/calib3d/calib3d.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include <stdio.h>
+#include <iostream>
+
+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"
+    //# include "../common.cpp"
+
+    int opencv_epipolarlines(char *fname, unsigned long fname_len)
+    {
+    	SciErr sciErr;
+    	int intErr=0;
+
+        //-> Mat containers for images
+        Mat img_1;
+        Mat img_2;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+
+        //-> Local variables
+        int *outList = NULL;
+        unsigned char *red = NULL;
+        unsigned char *green = NULL;
+        unsigned char *blue = NULL; 
+
+        int *outList2 = NULL;
+        unsigned char *red2 = NULL;
+        unsigned char *green2 = NULL;
+        unsigned char *blue2 = NULL; 
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        CheckInputArgument(pvApiCtx, 1, 5);                     //Check on Number of Input Arguments
+        CheckOutputArgument(pvApiCtx, 1, 5);                    //Check on Number of Output Arguments
+
+    	//-> Read Image
+        retrieveImage( img_1, 1);
+        retrieveImage(img_2, 2);
+
+        //-> Count number of input arguments
+        //num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        //-> Based on number of input arguments
+
+//*****************************************************  Actual Processing  *************************************************************
+
+        //Mat img_1 = imread( "left.jpg", CV_LOAD_IMAGE_GRAYSCALE );
+    	//Mat img_2 = imread( "right.jpg", CV_LOAD_IMAGE_GRAYSCALE );
+
+        cvtColor(img_1, img_1, CV_BGR2GRAY);
+        cvtColor(img_2, img_2,CV_BGR2GRAY);
+
+    	//-- Step 1: Detect the keypoints using SURF Detector
+    	int minHessian = 400;
+
+    	SurfFeatureDetector detector( minHessian );
+
+    	std::vector<KeyPoint> keypoints_1, keypoints_2;
+
+    	detector.detect( img_1, keypoints_1 );
+    	detector.detect( img_2, keypoints_2 );
+
+    	//-- Step 2: Calculate descriptors (feature vectors)
+    	SurfDescriptorExtractor extractor;
+
+    	Mat descriptors_1, descriptors_2;
+
+      	extractor.compute( img_1, keypoints_1, descriptors_1 );
+      	extractor.compute( img_2, keypoints_2, descriptors_2 );
+
+    	//-- Step 3: Matching descriptor vectors using FLANN matcher
+    	FlannBasedMatcher matcher;
+    	std::vector< DMatch > matches;
+    	matcher.match( descriptors_1, descriptors_2, matches );
+
+    	double max_dist = 0; double min_dist = 100;
+    
+    	//-- Quick calculation of max and min distances between keypoints
+	    for( int i = 0; i < descriptors_1.rows; i++ )
+	    { double dist = matches[i].distance;
+	      if( dist < min_dist ) min_dist = dist;
+	      if( dist > max_dist ) max_dist = dist;
+	    }
+
+	    std::vector< DMatch > good_matches;
+	    vector<Point2f> points1,points2;
+    
+	    for( int i = 0; i < descriptors_1.rows; i++ )
+	    { //if( matches[i].distance <= max(2*min_dist, 0.02) )
+	    	if( matches[i].distance <= max(3*min_dist, 0.02) )
+	      { 
+	      	good_matches.push_back( matches[i]);
+	      	points2.push_back( keypoints_2[matches[i].trainIdx].pt );
+	      	points1.push_back( keypoints_1[matches[i].queryIdx].pt ); 
+	      }
+
+	    }
+
+  //***************** Finding Fundamental Matrix **************************
+
+	  vector<uchar> states;
+	  Mat f = findFundamentalMat(points1, points2, FM_RANSAC, 3, 0.99, states);
+	  //Mat F = findFundamentalMat(points1, points2, FM_LMEDS, 3, 0.99, states);
+	  string window = "epipolarlines";
+	  //drawEpipolarLines(window, fundamental_matrix, img_1, img_2, points1, points2);
+	 
+
+	  vector<Vec<float,3> > epilines1, epilines2;
+	  computeCorrespondEpilines(points1, 1, f, epilines1); //Index starts with 1
+	  computeCorrespondEpilines(points2, 2, f, epilines2);
+
+	  cvtColor(img_1,img_1,COLOR_GRAY2BGR);
+	  cvtColor(img_2,img_2,COLOR_GRAY2BGR);
+	  int inlierDistance = -1;
+	 // cout<<points1.size()<<endl<<points2.size( );
+	  cv::RNG rng(0);
+	  for(int i=0; i<points1.size(); i++)
+	  {
+	    /*if(inlierDistance > 0)
+	    {
+	      if(distancePointLine(points1[i], epilines2[i]) > inlierDistance ||
+	        distancePointLine(points2[i], epilines1[i]) > inlierDistance)
+	      {
+	        //The point match is no inlier
+	        continue;
+	      }
+	    } */
+
+	    //Mat outImg(img1.rows, img1.cols*2, CV_8UC3);
+	    //Rect rect1(0,0, img1.cols, img1.rows);
+
+//************************************************************* Draw epipolar lines function ********************************************************
+	     cv::Scalar color(rng(256),rng(256),rng(256));
+	     line(img_1, Point(0,-epilines1[i][2]/epilines1[i][1]), Point(img_1.cols,-(epilines1[i][2]+epilines1[i][0]*img_1.cols)/epilines1[i][1]),color);
+	     circle(img_1, points1[i], 3, color, -1, CV_AA);
+
+	     line(img_2, Point(0,-epilines1[i][2]/epilines1[i][1]), Point(img_2.cols,-(epilines1[i][2]+epilines1[i][0]*img_2.cols)/epilines1[i][1]),color);
+	     circle(img_2, points2[i], 3, color, -1, CV_AA);
+	  } 
+
+//************************************************ Returning first image **************************************************
+
+	  	if( img_1.channels() == 1)
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &outList);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            red = (unsigned char *)malloc(sizeof(unsigned char)*img_1.rows*img_1.cols);
+
+            for(int k=0;k<img_1.rows;k++)
+                for(int p=0;p<img_1.cols;p++)
+                    red[k+img_1.rows*p]=img_1.at<uchar>(k, p);
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, img_1.rows, img_1.cols, red);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }                       
+            free(red);
+        }
+
+        else
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, &outList);
+            if(sciErr.iErr)
+            {
+                    printError(&sciErr, 0);
+                    return 0;
+            }
+
+            red = (unsigned char *)malloc(sizeof(unsigned char)*img_1.rows*img_1.cols);
+            green = (unsigned char *)malloc(sizeof(unsigned char)*img_1.rows*img_1.cols);
+            blue = (unsigned char *)malloc(sizeof(unsigned char)*img_1.rows*img_1.cols);
+
+            for(int k=0;k<img_1.rows;k++)
+            {
+                for(int p=0;p<img_1.cols;p++)
+                {
+                    Vec3b intensity = img_1.at<Vec3b>(k, p);
+                    red[k+img_1.rows*p]=intensity.val[2];
+                    green[k+img_1.rows*p]=intensity.val[1];
+                    blue[k+img_1.rows*p]=intensity.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, img_1.rows, img_1.cols, red);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 2, img_1.rows, img_1.cols, green);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }                   
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 3, img_1.rows, img_1.cols, blue);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                free(red);
+                free(green);
+                free(blue); 
+
+        }
+
+
+		  /*imshow("title", img_1);
+		  waitKey(0);
+		  imshow("title2", img_2);
+		  waitKey(0);*/
+
+		  if( img_2.channels() == 1)
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, &outList2);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            red2 = (unsigned char *)malloc(sizeof(unsigned char)*img_2.rows*img_2.cols);
+
+            for(int k=0;k<img_2.rows;k++)
+                for(int p=0;p<img_2.cols;p++)
+                    red2[k+img_2.rows*p]=img_2.at<uchar>(k, p);
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, outList2, 1, img_2.rows, img_2.cols, red2);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }                       
+            free(red2);
+        }
+
+        else
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 3, &outList2);
+            if(sciErr.iErr)
+            {
+                    printError(&sciErr, 0);
+                    return 0;
+            }
+
+            red2 = (unsigned char *)malloc(sizeof(unsigned char)*img_2.rows*img_2.cols);
+            green2 = (unsigned char *)malloc(sizeof(unsigned char)*img_2.rows*img_2.cols);
+            blue2 = (unsigned char *)malloc(sizeof(unsigned char)*img_2.rows*img_2.cols);
+
+            for(int k=0;k<img_2.rows;k++)
+            {
+                for(int p=0;p<img_2.cols;p++)
+                {
+                    Vec3b intensity2 = img_2.at<Vec3b>(k, p);
+                    red2[k+img_2.rows*p]=intensity2.val[2];
+                    green2[k+img_2.rows*p]=intensity2.val[1];
+                    blue2[k+img_2.rows*p]=intensity2.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, outList2, 1, img_2.rows, img_2.cols, red2);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, outList2, 2, img_2.rows, img_2.cols, green2);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }                   
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, outList2, 3, img_2.rows, img_2.cols, blue2);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                free(red2);
+                free(green2);
+                free(blue2); 
+
+        }
+
+
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+        ReturnArguments(pvApiCtx);
+    	return 0;
+    }
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_erode.cpp b/sci_gateway1/cpp/opencv_erode.cpp
new file mode 100644
index 0000000..fd12082
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_erode.cpp
@@ -0,0 +1,117 @@
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <math.h>
+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"
+  
+  int opencv_erode(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    char **type = NULL;
+    int i,j,k;
+    double anchorX,anchorY,iterations;
+    double *kernel;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for kernel
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &kernel);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr,0);
+        return 0;
+    }
+
+    double actualkernel[iRows][iCols];
+    for(i=0;i<iRows;i++)
+        for(j=0;j<iCols;j++)
+            actualkernel[i][j]=kernel[(j*iRows)+i];
+
+    Mat kernelMatrix(iRows,iCols,CV_64F,&actualkernel);
+
+    //for value of anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&anchorX);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4 ,&anchorY);
+    if(intErr)
+        return intErr;
+
+    //for value of iterations
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&iterations);
+    if(intErr)
+        return intErr;
+
+    Mat new_image(image.rows,image.cols,image.type());
+    Point pt(anchorX,anchorY);
+
+    erode(image,new_image,kernelMatrix,pt,iterations);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_estimateFundamentalMatrix.cpp b/sci_gateway1/cpp/opencv_estimateFundamentalMatrix.cpp
new file mode 100644
index 0000000..4a2cec2
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_estimateFundamentalMatrix.cpp
@@ -0,0 +1,318 @@
+/****************************************************************************************************
+estimateFundamentalMatrix(InputArray1,InputArray2,'method','RANSAC','param1',2,'param2',0.99);
+
+possible methods are 7POINT,8POINT,RANSAC,LMEDS
+param1- It indiacates maximum distance from a point to an epipolar line in pixels
+param2- It specifies a desirable level of confidence
+*********************************************************	***********************************************/
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+#include <iostream>
+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"
+  
+  int opencv_estimateFundamentalMat(char *fname, unsigned long fname_len)
+  {
+  
+   SciErr sciErr;
+   int intErr=0;
+   int iComplex = 0;
+   int iType = 0;
+   int *piAddr  = NULL;
+   int *piLen = NULL;
+   int iRows,iCols;
+   int iA1Rows=0,iA1Cols=0,iA2Rows=0,iA2Cols=0;
+   int method=FM_RANSAC;
+   int nbInputArguments,iter,i,j;
+   char **pstData = NULL; 
+   char *currentArg = NULL; 
+   bool *providedArgs = NULL; 
+   double* pdblReal	= NULL;
+   double *iArray1=NULL,*iArray2=NULL;
+   double param1=3,param2=0.99;
+
+   vector<Point2f> point1,point2;
+  
+  CheckInputArgument(pvApiCtx, 2, 8);
+  CheckOutputArgument(pvApiCtx, 1, 1) ;
+  	
+  nbInputArguments = *getNbInputArgument(pvApiCtx); 
+  providedArgs = (bool*) malloc(sizeof(bool) * 3); 
+  
+  
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iA1Rows, &iA1Cols, &iArray1);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	
+	
+  	sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}
+	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iA2Rows, &iA2Cols, &iArray2);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	if(iA1Rows != iA2Rows)
+    {
+    	Scierror(999, "There must be the same number of points in both input arrays\n"); 
+        return 0; 
+    }
+    
+	for(i=0;i<iA1Rows;i++){
+		point1.push_back(Point2f(iArray1[i],iArray1[iA1Rows+i]));
+		point2.push_back(Point2f(iArray2[i],iArray2[iA2Rows+i]));
+	}
+	for(iter=3; iter<= nbInputArguments; iter++)
+    {
+		sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+        if (sciErr.iErr)
+        {
+        	printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+            
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+            
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            currentArg = pstData[0]; 
+            if(strcmp(currentArg, "method")==0)
+            {
+				//sciprint("in if\tcurrentArg:%s\n",currentArg);            
+                if(iter+1<=nbInputArguments && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+				    if (sciErr.iErr)
+				    {
+				        printError(&sciErr, 0); 
+				        return 0; 
+				    }
+				    
+				    piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+				    
+				    sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+				    if (sciErr.iErr)
+				    {
+				        printError(&sciErr, 0); 
+				        return 0; 
+				    }
+				    
+				    pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+				    for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+				    {
+				        pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+				    }
+				    
+				    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+				    if (sciErr.iErr)
+				    {
+				        printError(&sciErr, 0); 
+				        return 0; 
+				    }
+				    currentArg=pstData[0];
+                    // Checking if values are in proper range. Same for all optional arguments
+                    //sciprint("in if\tcurrentArg:%s\n",currentArg);
+                    if(strcmp(currentArg,"7POINT")==0)
+                    	 method = FM_7POINT;	  
+					else if (strcmp(currentArg,"8POINT")==0)
+						  method= FM_8POINT;
+					else if (strcmp(currentArg,"RANSAC")==0)
+						  method= FM_RANSAC;
+					else if (strcmp(currentArg,"LMEDS")==0)
+						  method= FM_LMEDS;
+					else
+					{
+						sciprint("Invalid method given. RANSAC was used instead");
+						method= FM_RANSAC;
+					}	  
+                    providedArgs[0] = 1; 
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }    
+            else if(strcmp(currentArg, "param1")==0)
+            {
+                if(iter+1 <= nbInputArguments  && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &param1); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    providedArgs[1] = 1; 
+                }
+                else if(providedArgs[1])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "param2")==0)
+            {
+                if(iter+1 <= nbInputArguments  && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &param2); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    providedArgs[2] = 1; 
+                }
+                else if(providedArgs[2])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else
+            {
+                Scierror(999, "Error: \"%s\" name for input argument is not valid.\n", currentArg); 
+                return 0; 
+            }
+	}
+	
+	if (method==FM_7POINT && point1.size()!=7){
+		Scierror(999, "Error: For FM_7POINT method number of points in each array must be 7\n"); 
+        return 0;
+	}
+	if (method!=FM_7POINT && point1.size()<8 ){
+		Scierror(999, "Error: Number of points in each array must be greater than or equal to 8\n");
+		return 0;
+	}
+	
+	Mat fm=cv::findFundamentalMat(point1, point2, method, param1, param2);
+	pdblReal = (double*) malloc(sizeof(double) * fm.rows *3); 
+	for(i = 0 ; i < fm.rows ; i++)
+	{
+		for(j = 0 ; j < 3 ; j++)
+		{
+			pdblReal[i + fm.rows * j] = fm.at<double>(i,j);
+		}
+	}
+	sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, fm.rows , 3, pdblReal);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
+    return 0;
+  }  
+}
diff --git a/sci_gateway1/cpp/opencv_estimateGeometricTransform.cpp b/sci_gateway1/cpp/opencv_estimateGeometricTransform.cpp
new file mode 100644
index 0000000..2a4ec4b
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_estimateGeometricTransform.cpp
@@ -0,0 +1,164 @@
+/*********************************************************************************
+*Author : Kevin George
+*
+*-> To execute, estimateGeometricTransform(I1,I2)
+*   where I1 & I2 are images
+* 
+*This program only gives an affine transformation matrix 
+*********************************************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include <iostream>
+#include <math.h>
+#include <vector>
+
+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"
+    // # include "../common.cpp"
+
+    int opencv_estimateGeometricTransform(char *fname, unsigned long fname_len)
+    {
+
+    	//-> Error Management variables
+    	SciErr sciErr;
+    	int intErr=0;
+
+        //-> Mat containers for images
+        Mat image_1;
+        Mat image_2;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+
+        //-> Local variables
+        int minHessian = 400;  //-> For SURF algorithm
+        int num_InputArgs; 
+        //-> KeyPoint is data structure to store a point feature
+        //   detected by a keypoint detector(OpenCV) 
+            vector<KeyPoint> keypoints_1;
+            vector<KeyPoint> keypoints_2;
+        Mat descriptors_1, descriptors_2;
+        Mat img_matches;
+        vector< DMatch > good_matches;
+        vector< DMatch > matches;
+        vector<Point2f> a,b;
+        double max_dist = 0; double min_dist = 100;
+        /*double *indexPairs = NULL;
+        double *matchMetric = NULL;
+        double size=1;
+        int iRows, iCols; */
+    
+        //KeyPoint *X = new KeyPoint; //-> Remember to free this Kevin
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        CheckInputArgument(pvApiCtx, 1, 5);                     //Check on Number of Input Arguments
+        CheckOutputArgument(pvApiCtx, 1, 5);                    //Check on Number of Output Arguments
+
+    	//-> Read Image
+        retrieveImage( image_1, 1);
+        retrieveImage(image_2, 2);
+
+        //-> Count number of input arguments
+        //num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        //-> Based on number of input arguments
+
+//*****************************************************  Actual Processing  *************************************************************
+      
+        //-- Step 1: Calculate keypoints
+        SurfFeatureDetector detector( minHessian );
+        detector.detect( image_1, keypoints_1 );
+        detector.detect( image_2, keypoints_2 );
+
+        //-- Step 2: Calculate descriptors (feature vectors)
+        SurfDescriptorExtractor extractor;
+        extractor.compute( image_1, keypoints_1, descriptors_1 );
+        extractor.compute( image_2, keypoints_2, descriptors_2 );
+
+        //-- Step 3: Matching descriptor vectors using FLANN matcher
+        FlannBasedMatcher matcher;
+        matcher.match( descriptors_1, descriptors_2, matches );
+
+        //-- Quick calculation of max and min distances between keypoints
+        for( int i = 0; i < descriptors_1.rows; i++ )
+        { 
+            double dist = matches[i].distance;
+            if( dist < min_dist ) min_dist = dist;
+            if( dist > max_dist ) max_dist = dist;
+        }
+
+        for( int i = 0; i < descriptors_1.rows; i++ )
+        { 
+            if( matches[i].distance <= max(2*min_dist, 0.02) )
+            { good_matches.push_back( matches[i]); }
+        }
+
+        //queryidx- keypoints1
+  		//traindidx-  keypoints2
+  	
+
+	    for(int i=0;i<3;i++)
+	    {
+	      a.push_back( keypoints_1[good_matches[i].queryIdx].pt );
+	      b.push_back( keypoints_2[good_matches[i].trainIdx].pt );
+	    }
+
+  	
+  	   Mat M = getAffineTransform( Mat(a), Mat(b)  );
+       
+  	 /*  double output[M.rows][M.cols];
+
+        for(int i=0; i<M.rows; ++i)
+       {
+          const double* Mi = M.ptr<double>(i);
+          for (int j = 0; j < M.cols; j++)
+          {
+             output[i][j] = Mi[j];
+          }
+       } */
+        double *output = NULL;
+        output = (double *)malloc(sizeof(double)*M.rows*M.cols);
+
+  	   //-> Accessing elements of Mat object M
+       for(int i=0; i<M.rows; ++i)
+   	   {
+          const double* Mi = M.ptr<double>(i);
+	      for (int j = 0; j < M.cols; j++)
+	      {
+	         output[i+j] = Mi[j];
+	      }
+  	   }
+        
+
+  	   sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+1, M.rows, M.cols, output); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+       //-> Returning Output
+       AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+       ReturnArguments(pvApiCtx);
+
+       return 0;
+    }
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_estimateUncalibratedRectification.cpp b/sci_gateway1/cpp/opencv_estimateUncalibratedRectification.cpp
new file mode 100644
index 0000000..c0078bd
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_estimateUncalibratedRectification.cpp
@@ -0,0 +1,201 @@
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+#include <iostream>
+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"
+  
+  int opencv_estimateUncalibratedRectification(char *fname, unsigned long fname_len)
+  {
+   SciErr sciErr;
+   int intErr=0;
+   int iComplex = 0;
+   int iType = 0;
+   int *piAddr  = NULL;
+   int i,j;
+   int iA1Rows=0,iA1Cols=0,iA2Rows=0,iA2Cols=0;
+   int fmRows=0,fmCols=0,imageRows=0,imageCols=0;
+   double *fm=NULL,*iArray1=NULL,*iArray2=NULL,*imageSize=NULL;
+   double *oArray1=NULL,*oArray2=NULL;
+   Mat fundamentalMatrix(3,3,CV_64F);
+   int imagesize[2];
+   vector<Point2f> points1,points2;
+   
+   CheckInputArgument(pvApiCtx, 4, 4);
+   CheckOutputArgument(pvApiCtx, 2, 2) ;
+   
+   
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &fmRows, &fmCols, &fm);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+   
+   
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iA1Rows, &iA1Cols, &iArray1);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	
+	
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iA2Rows, &iA2Cols, &iArray2);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	
+	
+	sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &imageRows, &imageCols, &imageSize);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	
+	if(fmRows!=3 || fmCols!=3)
+	{
+		Scierror(999, "Fudamental matrix must be of size 3*3\n"); 
+        return 0;
+	}
+	if(iA1Rows != iA2Rows)
+    {
+    	Scierror(999, "There must be the same number of points in both input arrays\n"); 
+        return 0; 
+    }
+    if(imageRows!=1 || (imageCols!=2 && imageCols!=3))
+	{
+		Scierror(999, "Image size must be of vector of  with 2 or 3 elements\n"); 
+        return 0;
+	}
+	for(i = 0 ; i < 3 ; i++)
+	{
+		for(j = 0 ; j < 3 ; j++)
+		{
+			fundamentalMatrix.at<double>(i,j) = fm[i+3*j];
+		}
+	}
+	for(i=0;i<iA1Rows;i++)
+	{
+		points1.push_back(Point2f(iArray1[i],iArray1[iA1Rows+i]));
+		points2.push_back(Point2f(iArray2[i],iArray2[iA2Rows+i]));
+	}
+	Mat H1,H2;
+	if (imageCols==2)
+		stereoRectifyUncalibrated(points1, points2, fundamentalMatrix,Size(imageSize[0],imageSize[1]), H1, H2);
+    else if (imageCols==3)
+    	stereoRectifyUncalibrated(points1, points2, fundamentalMatrix,Size(imageSize[0],imageSize[1],imageSize[2]), H1, H2);
+	oArray1 = (double*) malloc(sizeof(double) * 3 *3);
+	oArray2 = (double*) malloc(sizeof(double) * 3 *3);
+	for(i = 0 ; i < 3 ; i++)
+	{
+		for(j = 0 ; j < 3 ; j++)
+		{
+			oArray1[i + 3 * j] = H1.at<double>(i,j);
+			oArray2[i + 3 * j] = H2.at<double>(i,j);
+		}
+	}
+	sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3 , 3, oArray1);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 3 , 3, oArray2);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+	AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+    ReturnArguments(pvApiCtx);
+    return 0;
+  }
+}
diff --git a/sci_gateway1/cpp/opencv_evaluate.cpp b/sci_gateway1/cpp/opencv_evaluate.cpp
new file mode 100644
index 0000000..2794b90
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_evaluate.cpp
@@ -0,0 +1,417 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <iostream>
+#include <opencv2/opencv.hpp>
+#include <opencv2/nonfree/nonfree.hpp>
+#include <opencv2/ml/ml.hpp>
+
+using namespace std;
+using namespace cv;
+
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include "sciprint.h"
+    int opencv_evaluate(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr;
+
+        //------Local variables------//
+        int upright = 1;
+        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
+        Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(1, 4, 2, 1, int(upright));
+        BOWImgDescriptorExtractor bowDE(extractor, matcher);
+        SurfFeatureDetector detector(1, 4, 2, 1, int(upright));
+        char *classifierLocation = NULL;
+        Mat dictionary,inp,features;
+        double response;
+        vector<KeyPoint> keyPoints;
+        CvSVM svm;
+        int dictionarySize;
+        int *piAddr = NULL;
+        int *piChild = NULL;
+        int iRows, iCols;
+        char **pstData = NULL;
+        int *piLen = NULL;
+        int *count = NULL;
+        char **classifierDescription = NULL;
+        int classifierDescriptionCount;
+        char **description = NULL;
+        char ***location = NULL;
+        char *bagOfFeaturesLocation = NULL;
+        int descriptionCount;
+        double *confMatrix = NULL;
+        char *fileName = NULL;
+        double avgAccuracy = 0;
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 2, 2);
+        CheckOutputArgument(pvApiCtx, 1, 1);
+
+        //------Get input arguments------//
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        if(!isListType(pvApiCtx, piAddr))
+        {
+            Scierror(999, "Error: The input argument #1 is not of type classifier.\n");
+            return 0;
+        }
+
+        // Extracting object type and checking if type is classifier
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 1, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 1, &iRows, &iCols, piLen, pstData);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(!(strcmp(pstData[0],"classifier")==0))
+        {
+            Scierror(999, "Error: The input argument #1 is not of type classifier.\n");
+            return 0;
+        }
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 2,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, piLen, pstData);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows!=1 || iCols!=1)
+        {
+            Scierror(999, "1x1 Matrix expected for classifier argument.");
+            return 0;
+        }
+        classifierLocation = pstData[0];
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 3, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 3,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 3, &iRows, &iCols, piLen, pstData);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows!=1 || iCols!=1)
+        {
+            Scierror(999, "1x1 Matrix expected for bagOfFeatures argument.");
+            return 0;
+        }
+        bagOfFeaturesLocation = pstData[0];
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 4, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 4,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        classifierDescription = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            classifierDescription[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 4, &iRows, &iCols, piLen, classifierDescription);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        classifierDescriptionCount = iRows;
+        // Second Argument
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        if(!isListType(pvApiCtx, piAddr))
+        {
+            Scierror(999, "Error: The input argument #2 is not of type imageSet.\n");
+            return 0;
+        }
+
+        // Extracting object type and checking if type is imageSet
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 1, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 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 #2 is not of type imageSet.\n");
+            return 0;
+        }
+
+        // Extracting Description attribute of input argument
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 2, &iRows, &iCols, piLen, description);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        descriptionCount = iRows;
+
+        // Extracting Count attribute of input argument
+        sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &count);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        location = (char***) malloc(sizeof(char**) * descriptionCount);
+        sciErr = getListItemAddress(pvApiCtx, piAddr, 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;
+            }
+        }
+        //------Actual processing------//
+        if(descriptionCount != classifierDescriptionCount)
+        {
+            Scierror(999, "Error: The input imageSet does not match the classifier's training set.\n");
+            return 0;
+        }
+        for(int i=0; i<descriptionCount; i++)
+        {
+            if(strcmp(classifierDescription[i],description[i])!=0)
+            {
+                Scierror(999, "Error: The input imageSet does not match the classifier's training set.\n");
+                return 0;
+            }
+        }
+        sciprint("Evaluating image category classifier for %d categories.\n",descriptionCount);
+        sciprint("--------------------------------------------------------\n\n");
+        for(int i=0;i<descriptionCount;i++)
+        {
+            sciprint("# Category %d: %s\n",i+1,description[i]);
+        }
+        sciprint("\n");
+        confMatrix = (double*) malloc(sizeof(double)*descriptionCount*descriptionCount);
+        for(int i=0;i<descriptionCount*descriptionCount;i++)
+        {
+            confMatrix[i]=0;
+        }
+        FileStorage fs(bagOfFeaturesLocation, FileStorage::READ);
+        fs["dictionary"] >> dictionary;
+        fs.release();
+        dictionarySize = dictionary.rows;
+        bowDE.setVocabulary(dictionary);
+        svm.load(classifierLocation);
+        for(int i=0; i<descriptionCount;i++)
+        {
+            sciprint("# Evaluating %d images from category %d ...",count[i],i+1);
+            for(int j=0; j<count[i]; j++)
+            {
+                features.release();
+                keyPoints.clear();
+                fileName = location[i][j];
+                inp = imread(fileName);
+                detector.detect(inp, keyPoints);
+                bowDE.compute(inp, keyPoints, features);
+                response = svm.predict(features);
+                confMatrix[i+(int)response*descriptionCount]++;
+            }
+            sciprint("done.\n");
+        }
+        sciprint("\n");
+        sciprint("\t PREDICTED\n");
+        sciprint("KNOWN\t|");
+        for(int i=0;i<descriptionCount;i++)
+        {
+            sciprint(" %d\t",i+1);
+        }
+        sciprint("\n");
+        for(int i=0; i<descriptionCount;i++)
+        {
+            sciprint("%d\t|",i+1);
+            for(int j=0; j<descriptionCount; j++)
+            {
+                confMatrix[i+descriptionCount*j] /= count[i];
+                sciprint(" %.2f\t",confMatrix[i+descriptionCount*j]);
+            }
+            sciprint("\n");
+        }
+        sciprint("\n");
+        for(int i=0;i<descriptionCount*descriptionCount;i=i+descriptionCount+1)
+        {
+            avgAccuracy += confMatrix[i];
+        }
+        sciprint("# Average accuracy: %f\n",avgAccuracy/descriptionCount);
+        //------Create output arguments------//
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+1, descriptionCount, descriptionCount, confMatrix);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    /* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_evaluateImageRetrieval.cpp b/sci_gateway1/cpp/opencv_evaluateImageRetrieval.cpp
new file mode 100644
index 0000000..d8bed5c
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_evaluateImageRetrieval.cpp
@@ -0,0 +1,566 @@
+#
+/*************************************************************************************************************************************
+* Author: Umang Agrawal                                                                                                              *
+* Code: evaluateImageRetrieval.cpp                                                                                                   *
+* Funtion Call:    [ Average_Precision, Index, Score ] = evaluateImageRetreival( QureyImage, IndexImage, Expected Index, OptionalArgument)    *
+*         Optional Argument:          Name                      Value                                                                *
+*                                   NumResults           Any Value greater than 0                                                    *
+*                                     ROI       [ x_coordinate y_coordinate width height ]                                           *
+*************************************************************************************************************************************/
+#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"
+#include "opencv2/ml/ml.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 count_based(const vector<int>& a, const vector<int>& b);// {
+    //  return a[1] > b[1];
+  //}
+
+	int opencv_evaluateImageRetrieval(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+
+    int *piAddr = NULL;
+    int *piAddr2 = NULL;
+    int *piAddr3 = NULL;
+    int *piAddr4 = NULL;
+    int *piAddr5 = NULL;
+    int *piChild = NULL;
+    int *piGrandChild = NULL;
+    int *piLen = NULL;
+    char **pstData = NULL;
+    int iRows, iCols;
+    int no_item_list = 0;
+    int no_item_list_2 = 0;
+    int inp_params = 0;
+    char **arg = NULL;
+
+    double *expectedID = NULL;
+    char ***location_img = NULL;
+    double **WordIndex = NULL;
+    double **Location = NULL;
+    double **Vocab_size = NULL;
+    double **Count = NULL;
+    double *wordFrequency = NULL;
+    char *bagOfFeaturesLocation = NULL;
+    int count_res = 0, count_roi = 0;
+    double numRes = 0;
+    double *roi_arg = NULL;
+    double x, y, width, height;
+    int no_expectation = 0;
+    int count;
+
+    Mat image;
+    Mat feature_des;
+    Mat dictionary;
+    Mat des_matched;
+    Mat hist;
+    vector<KeyPoint> keypoints;
+    vector<KeyPoint> valid_key;
+    vector< vector<int> > clusterID;
+    vector<int> WordIndex_size;
+    vector<int> avg_ID;
+
+    int indx;
+    int search_ind;
+    double *Index_Out = NULL;
+    double *Score = NULL;
+    double **ImageWords = NULL;
+    double avg_prec = 0;
+
+    CheckInputArgument(pvApiCtx, 3, 7);						//Check on Number of Input Arguments
+		CheckOutputArgument(pvApiCtx, 1, 3);						//Check on Number of Output Arguments
+
+    retrieveImage(image, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    if(!isListType(pvApiCtx, piAddr2))
+    {
+        Scierror(999, "Error: Invalid Second argument. List Expected.\n");
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx, piAddr2, &no_item_list);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 1, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 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, piAddr2, 1, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    if(!(strcmp(pstData[0],"invertedImageIndex")==0))
+    {
+        Scierror(999, "Error: The input argument 2 is not of type invertedImageIndex.\n");
+        return 0;
+    }
+
+    sciErr = getListItemAddress(pvApiCtx, piAddr2, 2, &piChild);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx, piChild, &no_item_list_2);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    WordIndex = (double**)malloc(sizeof(double*)*no_item_list_2);
+    Location = (double**)malloc(sizeof(double*)*no_item_list_2);
+    Vocab_size = (double**)malloc(sizeof(double*)*no_item_list_2);
+    Count = (double**)malloc(sizeof(double*)*no_item_list_2);
+    for( int i=0; i<no_item_list_2; i++)
+    {
+      sciErr = getListItemAddress(pvApiCtx, piChild, i+1, &piGrandChild);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 1, &iRows, &iCols, &WordIndex[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      WordIndex_size.push_back(iRows);
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 2, &iRows, &iCols, &Location[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 3, &iRows, &iCols, &Vocab_size[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 4, &iRows, &iCols, &Count[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+    }
+    sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr2, 3, &iRows, &iCols, &wordFrequency);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 4, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 4, &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, piAddr2, 4, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    bagOfFeaturesLocation = pstData[0];
+    if(no_item_list == 5)
+    {
+      location_img = (char***)malloc(sizeof(char**)*1);
+      sciErr = getListItemAddress(pvApiCtx, piAddr2, 5, &piChild);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, 1, &iRows, &iCols, NULL, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, 1, &iRows, &iCols, piLen, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      location_img[0] = (char**)malloc(sizeof(char*) * iRows * iCols);
+      for(int colIter = 0 ; colIter < iRows * iCols ; colIter++)
+      {
+        location_img[0][colIter] = (char*)malloc(sizeof(char) * (piLen[colIter] + 1));//+ 1 for null termination
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, 1, &iRows, &iCols, piLen, location_img[0]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    if( !isVarMatrixType(pvApiCtx, piAddr3))
+    {
+      Scierror(999,"Expecting a Matrix indicating the number of Expected IDs\n");
+      return 0;
+    }
+    if(!(isDoubleType(pvApiCtx, piAddr3)||isIntegerType(pvApiCtx, piAddr3)))
+    {
+      Scierror(999,"Expecting a matrix of integer values indicating the indices of Expected IDs\n");
+      return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols, &expectedID);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    if(iRows==1 && iCols!=1)
+      no_expectation = iCols;
+    else if(iRows!=1 && iCols==1)
+      no_expectation = iRows;
+    else no_expectation = iRows;
+
+    inp_params = *getNbInputArgument(pvApiCtx);
+    for( int i=4; 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, &piAddr4);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      //Check for Argument type
+      if( !isStringType(pvApiCtx, piAddr4))
+      {
+        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, piAddr4, &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, piAddr4, &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, piAddr4, &iRows, &iCols, piLen, arg);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        free(piLen);
+        free(arg);
+        return 0;
+      }
+
+      if(strcmp(arg[0],"NumResuts") == 0)
+      {
+        if(count_res != 0)
+        {
+          Scierror(999,"NumResults Argument has been called twice.\n");
+          return 0;
+        }
+        free(arg);
+        free(piLen);
+        sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr5);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Checking the type of value
+				if(!(isDoubleType(pvApiCtx, piAddr4)||isIntegerType(pvApiCtx, piAddr5)))
+				{
+					Scierror(999,"Not a valid type of value for NumResults.\n");
+          return 0;
+				}
+        if(getScalarDouble(pvApiCtx, piAddr5, &numRes))
+        {
+          Scierror(999,"Error Reading value of NumResults Argument\n");
+          return 0;
+        }
+        if(numRes < 0)
+        {
+          Scierror(999,"Not a valid value for NumResults\n");
+          return 0;
+        }
+        i++;
+        count_res += 1;
+      }
+      else if(strcmp(arg[0],"ROI") == 0)
+      {
+        if(count_roi != 0)
+        {
+          Scierror(999,"ROI Argument has been called twice.\n");
+          return 0;
+        }
+        free(arg);
+        free(piLen);
+        sciErr = getVarAddressFromPosition(pvApiCtx, i+1, &piAddr5);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Checking the type of argument
+				if(!(isDoubleType(pvApiCtx, piAddr5)||isIntegerType(pvApiCtx, piAddr5)))
+				{
+					Scierror(999,"Not a valid type of value.\n");
+          return 0;
+				}
+				//Reading the Value of the argument
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr5, &iRows, &iCols, &roi_arg);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Assigning the elements of the list to their proper function
+				x = roi_arg[0];
+				y = roi_arg[1];
+				width = roi_arg[2];
+				height = roi_arg[3];
+        i++;
+        count_roi += 1;
+      }
+      else
+      {
+        Scierror(999,"Invalid Argument Name\n");
+        return 0;
+      }
+    }
+
+    if(count_roi != 0)
+    {
+      Rect masker(x, y, width, height);
+      Mat croppedRef(image, masker);
+      image = Mat();
+      croppedRef.copyTo(image);
+    }
+
+    FileStorage fs(bagOfFeaturesLocation, FileStorage::READ);
+    fs["dictionary"] >> dictionary;
+    fs.release();
+
+    SurfFeatureDetector detector(100, 4, 2, 1, 1);
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
+    Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(100, 4, 2, 1, 1);
+    BOWImgDescriptorExtractor bowDE(extractor, matcher);
+    bowDE.setVocabulary(dictionary);
+    detector.detect(image, keypoints);
+    bowDE.compute(image, keypoints, hist, &clusterID, &des_matched);
+
+    ImageWords = (double**)malloc(sizeof(double*)*4*1);
+    ImageWords[0] = (double*)malloc(sizeof(double)*keypoints.size()*1);
+    ImageWords[1] = (double*)malloc(sizeof(double)*keypoints.size()*2);
+    ImageWords[2] = (double*)malloc(sizeof(double)*1);
+    ImageWords[3] = (double*)malloc(sizeof(double)*1);
+
+    ImageWords[2][0] = Vocab_size[0][0];
+    ImageWords[3][0] = keypoints.size();
+
+    vector<vector<int> > count_index(no_item_list_2 , vector<int>(3));
+
+    for( int i=0; i<keypoints.size(); i++)
+    {
+      ImageWords[1][i] = keypoints[i].pt.x;
+      ImageWords[1][keypoints.size() + i] = keypoints[i].pt.y;
+    }
+    for( int i=0; i<clusterID.size(); i++)
+    {
+      for( int j=0; j<clusterID[i].size(); j++)
+      {
+          indx = clusterID[i][j];
+          ImageWords[0][indx] = i;
+      }
+    }
+
+    for( int i=0; i<no_item_list_2; i++)
+    {
+      count = 0;
+      for( int j=0; j<keypoints.size(); j++)
+      {
+        search_ind = ImageWords[0][j];
+        for( int k=0; k<WordIndex_size[i]; k++)
+        {
+          if(int(WordIndex[i][k]) == int(search_ind))
+          {
+            count += 1;
+            break;
+          }
+        }
+      }
+      count_index[i][0] = i+1;
+      count_index[i][1] = count;
+      count_index[i][2] = WordIndex_size[i];
+    }
+
+    sort(count_index.begin(), count_index.end(), count_based);
+    if(count_res == 0 || no_item_list_2<numRes)
+      numRes = no_item_list_2;
+    Index_Out = (double*)malloc(sizeof(double)*numRes);
+    Score = (double*)malloc(sizeof(double)*numRes);
+    for( int i=0; i<numRes; i++)
+    {
+      Index_Out[i] = count_index[i][0];
+      Score[i] = double(count_index[i][1])/double(keypoints.size());
+    }
+
+    int flag = 0;
+    for( int i =0; i<no_expectation; i++)
+    {
+      if(expectedID[i] <= 0 || expectedID[i]>no_item_list_2 )
+      {
+        Scierror(999,"Not a valid expected Index ID. \n");
+        return 0;
+      }
+      int k = int(expectedID[i]);
+      if( i==0 )
+      {
+        for( int j=0; j<WordIndex_size[k-1]; j++)
+        {
+          avg_ID.push_back(WordIndex[k-1][j]);
+        }
+      }
+      else
+      {
+        for( int j=0; j<WordIndex_size[k-1]; j++)
+        {
+          flag = 0;
+          search_ind = WordIndex[k-1][j];
+          for( int k=0; k<avg_ID.size(); k++)
+          {
+            if( avg_ID[k] == search_ind)
+            {
+              flag = 1;
+            }
+          }
+          if(flag==0)
+          avg_ID.push_back(search_ind);
+        }
+      }
+    }
+
+    count = 0;
+    for( int i=0; i<keypoints.size(); i++)
+    {
+      search_ind = ImageWords[0][i];
+      for( int j=0; j<avg_ID.size(); j++)
+      {
+        if(search_ind == avg_ID[j])
+        {
+          count += 1;
+          break;
+        }
+      }
+    }
+    avg_prec = double(count)/double(keypoints.size());
+
+    if(createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, avg_prec))
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, numRes, 1, Index_Out);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, numRes, 1, Score);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2;
+    AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3;
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+
+}
diff --git a/sci_gateway1/cpp/opencv_extractFeatures.cpp b/sci_gateway1/cpp/opencv_extractFeatures.cpp
new file mode 100644
index 0000000..abb8ffc
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_extractFeatures.cpp
@@ -0,0 +1,1706 @@
+#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"
+
+	/*string type2str(int type) 
+	{
+  		string r;
+  		uchar depth = type & CV_MAT_DEPTH_MASK;
+  		uchar chans = 1 + (type >> CV_CN_SHIFT);
+  		switch ( depth ) 
+		{
+    		case CV_8U:  r = "8U"; break;
+    		case CV_8S:  r = "8S"; break;
+    		case CV_16U: r = "16U"; break;
+    		case CV_16S: r = "16S"; break;
+    		case CV_32S: r = "32S"; break;
+    		case CV_32F: r = "32F"; break;
+    		case CV_64F: r = "64F"; break;
+    		default:     r = "User"; break;
+  		}
+  		r += "C";
+  		r += (chans+'0');
+		return r;
+	}*/
+
+	int opencv_extractFeatures(char *fname, unsigned long fname_len)
+	{
+		//......................................................................................................................................................................................
+		//Declarations
+		// Error Handling		
+		SciErr sciErr;
+
+		// Address of Various Scilab API
+		int *piAddr1 = NULL;
+		int *piAddr2 = NULL;
+		int *piAddr3 = NULL;
+		int *piAddr4 = NULL;
+
+		// Number of input and output Arguments
+		int inputArguments = 0;
+		int out_params;
+
+		// Matrix Reading Argument
+		int iPrec = 0;
+		int noItemInList = 0;
+		int iRows,iCols;
+		int Rows, Cols;	
+		int *pilen = NULL;
+		char **arg = NULL;
+		char **method = NULL;
+		char **clas = NULL;
+		int length_M = 0;
+
+		// Necessary Output Arguments
+		double *valid_points = NULL;	
+		double numBits = 0;
+		double numFeatures = 0;
+		double *featureVector = NULL;	
+
+		// Count of various Arguments
+		int count_method=0, count_block=0, count_surf=0, count_upright=0 ,count_metric=0;
+		int count_orient=0, count_scale=0, count_axes=0, count_sign=0, count_class=0;
+		
+		// Iterator
+		int i;
+		
+		//Input Arguments Parameters
+		double *metric = NULL;
+		double *orient = NULL;
+		double *axes = NULL;
+		double *scale = NULL;
+		double *sign = NULL;
+		double block_size = 0;
+		double upright = 0;
+		double surf_size = 64;
+
+		// Keypoint Vector
+		vector<KeyPoint> keypoints;
+		vector<KeyPoint> copy_k;
+
+		//Image Container
+		Mat image;
+
+		//Output Argument
+		int feature_rows, feature_cols;
+		int valid_rows;
+		double count;
+		double *metric_o = NULL;
+		double *scale_o = NULL;	
+		double *orientation_o = NULL;
+		double *axes_o = NULL;
+		double *sign_o = NULL;
+
+		// Checks on Number of Input and Output Arguments
+		CheckInputArgument(pvApiCtx, 4, 22);
+		CheckOutputArgument(pvApiCtx, 2, 9);
+
+		inputArguments = *getNbInputArgument(pvApiCtx);
+		
+		//.......................................................................................................................................................................................
+		//Checking for the Presence of Valid Number of Arguments
+		if( inputArguments%2 == 0)
+		{
+			
+			//Argument 1 - Image
+			sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			if(isListType(pvApiCtx, piAddr1))
+			{
+				sciErr = getListItemNumber(pvApiCtx, piAddr1, &noItemInList);
+				if( noItemInList != 1)
+				{
+					Scierror(999,"Expecting a grayscale image as first Argument\n");
+					return 0;
+				}
+				retrieveImage(image, 1);
+			}
+			else
+			{
+				if( !isDoubleType(pvApiCtx, piAddr1))
+				{
+					Scierror(999,"Expecting a grayscale Image as first Argument\n");
+					return 0;
+				}
+				retrieveImage(image, 1);
+			}
+
+			
+			//..............................................................................................................................................................................
+			//Argument 2 - Location Co-ordinates
+			sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			if( !isVarMatrixType(pvApiCtx, piAddr2))
+			{
+				Scierror(999,"Expecting a Matrix of Mx2 order depicting the Location Coordinates as 2nd Argument.\n");
+				return 0;
+			}
+			//Checking the type of location coordinates
+			if(isDoubleType(pvApiCtx, piAddr2))
+			{
+				//for double location co-ordinates 
+				double *points = NULL;	
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &points);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;	
+				}
+				length_M = iRows;
+				KeyPoint *X = new KeyPoint;
+				for(int i=0; i<iRows; i++)
+				{
+					X->pt = Point2f(points[i],points[iRows+i]);
+					X->size = 7;
+					keypoints.push_back(*X);
+					copy_k.push_back(*X);
+				}
+			}
+			else if(isIntegerType(pvApiCtx, piAddr2))
+			{
+				sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr2, &iPrec);
+        			if(sciErr.iErr)
+        			{
+            				printError(&sciErr, 0);
+           				return 0;
+    			    	}
+				switch(iPrec)
+			        {
+			           	case SCI_UINT8: 	//for unsigned integer 8 location co-ordinates
+            					{				
+						unsigned char *points = NULL;
+						sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr2, &iRows, &iCols, &points);
+						if(sciErr.iErr)						
+						{
+							printError(&sciErr, 0);
+							return 0;	
+						}
+						length_M = iRows;
+						KeyPoint *X = new KeyPoint;
+						for(int i=0; i<iRows; i++)
+						{
+							X->pt = Point2f(points[i],points[iRows+i]);
+							X->size = 7;
+							keypoints.push_back(*X);
+							copy_k.push_back(*X);
+						}
+						break;
+						}
+					case SCI_UINT16:	//for unsigned integer 16 location co-ordinates
+						{
+						unsigned short *points = NULL;	
+						sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr2, &iRows, &iCols, &points);
+						if(sciErr.iErr)
+						{
+							printError(&sciErr, 0);
+							return 0;	
+						}
+						length_M = iRows;
+						KeyPoint *X = new KeyPoint;
+						for(int i=0; i<iRows; i++)
+						{
+							X->pt = Point2f(points[i],points[iRows+i]);
+							X->size = 7;
+							keypoints.push_back(*X);
+							copy_k.push_back(*X);
+						}
+						break;
+						}
+					case SCI_INT32:
+						{
+						int *points = NULL;
+						sciErr = getMatrixOfInteger32(pvApiCtx, piAddr2, &iRows, &iCols, &points);
+						if(sciErr.iErr)
+						{
+							printError(&sciErr, 0);
+							return 0;	
+						}
+						length_M = iRows;
+						KeyPoint *X = new KeyPoint;
+						for(int i=0; i<iRows; i++)
+						{
+							X->pt = Point2f(points[i],points[iRows+i]);
+							X->size = 7;
+							keypoints.push_back(*X);
+							copy_k.push_back(*X);
+						}
+						break;
+						}
+				}
+			}
+			else
+			{
+				Scierror(999,"Expecting a Double or an Integer Matrix as Location Coordinates in 2nd Argument.\n");
+				return 0;
+			}
+
+
+			//.............................................................................................................................................................................
+			//Argument 3 - Class
+			sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			//Check for Argument type
+			if( !isStringType(pvApiCtx, piAddr3))
+			{
+				Scierror(999,"Expecting String Argument \"Class\" as Argument 3.\n");
+				return 0;
+			}
+			//Matrix of Stings
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &Rows, &Cols, NULL, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			pilen = (int*)malloc(sizeof(int) * Rows * Cols);
+			//second call to retrieve the length of the string
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &Rows, &Cols, pilen, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(pilen);
+				return 0;
+			}
+			arg = (char**)malloc(sizeof(char*) * Rows * Cols);
+			for(int j=0;j< Rows * Cols; j++)
+			{
+				arg[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+			}
+			//third call to retrieve data
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &Rows, &Cols, pilen, arg);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(pilen);
+				free(arg);
+				return 0;
+			}
+			
+			//Checking Whether Argument 3 is Method or not
+			if(strcmp(arg[0],"Class") == 0)
+			{
+				//If method extracting the Value of the Argument
+				if(count_class != 0)
+				{
+					Scierror(999,"Class Argument has been called twice\n");
+					return 0;
+				}
+				free(arg);
+				free(pilen);				
+				sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Check for Argument type
+				if( !isStringType(pvApiCtx, piAddr4))
+				{
+					Scierror(999, "%s: Wrong type of 2nd argument #%d. A string is expected.\n", fname, 1);
+					return 0;
+				}
+				//Matrix of Stings
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &Rows, &Cols, NULL, NULL);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				pilen = (int*)malloc(sizeof(int) * Rows * Cols);
+				//second call to retrieve the length of the string
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &Rows, &Cols, pilen, NULL);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					return 0;
+				}
+				clas = (char**)malloc(sizeof(char*) * Rows * Cols);
+				for(int j=0;j< Rows*Cols; j++)
+				{
+					clas[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+				}
+				//third call to retrieve data
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &Rows, &Cols, pilen, clas);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					free(clas);
+					return 0;
+				}
+				count_class += 1;
+			}
+			else 
+			{
+				Scierror(999,"Expecting \"Class\" as the 3rd Argument\n");
+				return 0;
+			}
+		}
+		else
+		{
+			Scierror(999,"Required Arguments are Missing\n");
+			return 0;
+		}
+		
+
+
+
+		//..........................................................................................................................................................................................
+		//Getting Optional Input Arguments
+		for( i=5; i<= inputArguments; i++)
+		{
+			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 #%d. A string is expected.\n", fname, 1);
+				return 0;
+			}
+			//Matrix of Stings
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &Rows, &Cols, NULL, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			pilen = (int*)malloc(sizeof(int) * Rows * Cols);
+			//second call to retrieve the length of the string
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &Rows, &Cols, pilen, NULL);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(pilen);
+				return 0;
+			}
+			arg = (char**)malloc(sizeof(char*) * Rows * Cols);
+			for(int j=0;j< Rows * Cols; j++)
+			{
+				arg[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+			}
+			//third call to retrieve data
+			sciErr = getMatrixOfString(pvApiCtx, piAddr3, &Rows, &Cols, pilen, arg);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				free(pilen);
+				free(arg);
+				return 0;
+			}
+
+
+
+			//.................................................................................................................................................................................
+			//Reading the Value of Optional Arguments
+			//If Optional Argument is Method
+			if(strcmp(arg[0],"Method") == 0)
+			{
+				if(count_method!= 0)
+				{
+					Scierror(999,"Method Argument 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;
+				}
+				//Check for Argument type
+				if( !isStringType(pvApiCtx, piAddr4))
+				{
+					Scierror(999, "%s: Wrong type of 2nd argument #%d. A string is expected.\n", fname, 1);
+					return 0;
+				}
+				//Matrix of Stings
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &Rows, &Cols, NULL, NULL);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				pilen = (int*)malloc(sizeof(int) * Rows * Cols);
+				//second call to retrieve the length of the string
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &Rows, &Cols, pilen, NULL);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					return 0;
+				}
+				method = (char**)malloc(sizeof(char*) * Rows * Cols);
+				for(int j=0;j< Rows*Cols; j++)
+				{
+					method[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+				}
+				//third call to retrieve data
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &Rows, &Cols, pilen, method);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					free(method);
+					return 0;
+				}
+				i++;
+				count_method += 1;
+			}
+			//.................................................................................................................................................................................
+			//If Optional Argument is Metric
+			else if(strcmp(arg[0],"Metric") == 0)
+			{
+				if(count_metric != 0)
+				{
+					Scierror(999,"Metric Argument 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;
+				}
+				//Check for Argument type
+				if( !isVarMatrixType(pvApiCtx, piAddr4))
+				{
+					Scierror(999,"Expecting a Matrix of Mx1 order depicting the Metric Values as Value of Metric Argument.\n");
+					return 0;
+				}
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &metric);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;	
+				}
+				if( iCols != 1)
+				{
+					Scierror(999,"Expecting a single Column Metric Matrix\n");
+					return 0;
+				}
+				if( iRows != length_M)
+				{
+					Scierror(999,"Expecting a M Row matrix having M number of elements corresponding to M rows of location coordinates\n");
+					return 0;
+				}
+				i++;
+				count_metric += 1;
+			}
+			//.................................................................................................................................................................................
+			//If Optional Argument is BlockSize
+			else if(strcmp(arg[0],"BlockSize") == 0)
+			{
+				if(count_block != 0)
+				{
+					Scierror(999,"BlockSize 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;
+				}
+				//Check for Argument type
+				if( !(isDoubleType(pvApiCtx, piAddr4)) )
+				{
+					Scierror(999,"BlockSize Value should be an odd Integer\n");
+					return 0;
+				}
+				if(getScalarDouble(pvApiCtx, piAddr4, &block_size))
+				{
+					Scierror(999,"Cannot Read Block Size Value");
+					return 0;
+				}
+				if(int(block_size)%2 == 0)
+				{
+					Scierror(999,"Expecting a odd value for Block Size");
+					return 0;
+				}
+				i++;
+				count_block += 1;
+			}
+			//.................................................................................................................................................................................
+			//If Optional Argument is Upright
+			else if(strcmp(arg[0],"Upright") == 0)
+			{
+				if(count_upright != 0)
+				{
+					Scierror(999,"Upright Argument 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;
+				}
+				//Check for Argument type
+				if( !(isDoubleType(pvApiCtx, piAddr4)) )
+				{
+					Scierror(999,"Upright Value must be a logic scalar\n");
+					return 0;
+				}
+				if(getScalarDouble(pvApiCtx, piAddr4, &upright))
+				{
+					Scierror(999,"Cannot Read Upright Value\n");
+					return 0;
+				}
+				i++;
+				count_upright += 1;
+			}
+			//.................................................................................................................................................................................
+			//If Optional Argument is SURFSize
+			else if(strcmp(arg[0],"SURFSize") == 0)
+			{
+				if(count_surf != 0)
+				{
+					Scierror(999,"SURFSize Argument 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;
+				}
+				//Check for Argument type
+				if( !(isDoubleType(pvApiCtx, piAddr4)) )
+				{
+					Scierror(999,"Surf Size Value should be an Integer\n");
+					return 0;
+				}
+				if(getScalarDouble(pvApiCtx, piAddr4, &surf_size))
+				{
+					Scierror(999,"Cannot Read Surf Size Value");
+					return 0;
+				}
+				if( int(surf_size) != 64 && int(surf_size) !=128 )
+				{
+					Scierror(999,"Expecting value 64 or 128 for Surf Size\n");
+					return 0;
+				}
+				i++;
+				count_surf += 1;
+			}
+			//.................................................................................................................................................................................
+			//If Optional Argument is Orientation
+			else if(strcmp(arg[0],"Orientation") == 0)
+			{
+				if(count_orient != 0)
+				{
+					Scierror(999,"Orientation Argument 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;
+				}
+				//Check for Argument type
+				if( !isVarMatrixType(pvApiCtx, piAddr4))
+				{
+					Scierror(999,"Expecting a Matrix of Mx1 order depicting the Orientation Values as Value of Orientation Argument.\n");
+					return 0;
+				}
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &orient);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;	
+				}
+				if( iCols != 1)
+				{
+					Scierror(999,"Expecting a single Column Orientation Matrix\n");
+					return 0;
+				}
+				if( iRows != length_M)
+				{
+					Scierror(999,"Expecting a M Row matrix having M number of elements corresponding to M rows of location coordinates\n");
+					return 0;
+				}
+				i++;
+				count_orient += 1;
+			}
+			//.................................................................................................................................................................................
+			//If Optional Argument is Axes
+			else if(strcmp(arg[0],"Axes") == 0)
+			{
+				if(count_axes != 0)
+				{
+					Scierror(999,"Axes Argument 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;
+				}
+				//Check for Argument type
+				if( !isVarMatrixType(pvApiCtx, piAddr4))
+				{
+					Scierror(999,"Expecting a Matrix of Mx2 order depicting the Axes as Value of Axes Argument.\n");
+					return 0;
+				}
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &axes);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;	
+				}
+				if( iCols != 2)
+				{
+					Scierror(999,"Expecting a 2 Column Axes Matrix\n");
+					return 0;
+				}
+				if( iRows != length_M)
+				{
+					Scierror(999,"Expecting a M Row matrix having M number of elements corresponding to M rows of location coordinates\n");
+					return 0;
+				}
+				i++;
+				count_axes += 1;
+			}
+			//................................................................................................................................................................................
+			//If Optional Argument is Scale
+			else if(strcmp(arg[0],"Scale") == 0)
+			{
+				if(count_scale != 0)
+				{
+					Scierror(999,"Scale Argument 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;
+				}
+				//Check for Argument type
+				if( !isVarMatrixType(pvApiCtx, piAddr4))
+				{
+					Scierror(999,"Expecting a Matrix of Mx1 order depicting the Scale as Value of Scale Argument.\n");
+					return 0;
+				}
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &scale);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;	
+				}
+				if( iCols != 1)
+				{
+					Scierror(999,"Expecting a single Column Scale Matrix\n");
+					return 0;
+				}
+				if( iRows != length_M)
+				{
+					Scierror(999,"Expecting a M Row matrix having M number of elements corresponding to M rows of location coordinates\n");
+					return 0;
+				}
+				i++;
+				count_scale += 1;	
+			}
+			//................................................................................................................................................................................
+			//If Optional Argument is SignOfLaplacian
+			else if(strcmp(arg[0],"SignOfLaplacian") == 0)
+			{
+				if(count_sign != 0)
+				{
+					Scierror(999,"SignOfLaplacian Argument 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;
+				}
+				//Check for Argument type
+				if( !isVarMatrixType(pvApiCtx, piAddr4))
+				{
+					Scierror(999,"Expecting a Matrix of Mx1 order depicting the Sign Of Laplacian as Value of SignOfLaplacian Argument.\n");
+					return 0;
+				}
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &sign);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;	
+				}
+				if( iCols != 1)
+				{
+					Scierror(999,"Expecting a single Column Axes Matrix\n");
+					return 0;
+				}
+				if( iRows != length_M)
+				{
+					Scierror(999,"Expecting a M Row matrix having M number of elements corresponding to M rows of location coordinates\n");
+					return 0;
+				}
+				i++;
+				count_sign += 1;
+				//Check for Validity of Laplacian Matrix
+				for(int i=0; i<iRows; i++)
+				{
+					if( !(sign[i]==0 || sign[i]==1 || sign[i]==-1))
+					{
+						Scierror(999,"SignOfLaplacian Matrix should contain only 0,1 or -1 as its elements.\n");
+						return 0;
+					}
+				}
+			}
+			else
+			{
+				Scierror(999, "Invalid Argument Name. Provide Valid Arguments\n");
+				return 0;
+			}
+		}
+
+
+		//Reading Part Completed
+		//.........................................................................................................................................................................................
+		//.........................................................................................................................................................................................
+		//Checking for Presence of All necessary Arguments for the computation of specified Method		
+		if(strcmp(clas[0], "cornerPoints") == 0)
+		{
+			if(count_metric==0)
+			{
+				Scierror(999,"For cornerPoints Object \"Metric\" Matrix is necessary.\n");
+				return 0;
+			}
+			if(count_method==0)
+			{
+				method = (char**)malloc(sizeof(char*) * 1 * 1);
+				method[0] = (char*)malloc(sizeof(char) * 6);
+				strcpy(method[0],"FREAK");
+			}
+			for( i=0; i<keypoints.size(); i++)
+			{
+				keypoints[i].response = metric[i];
+			}
+		}
+		else if(strcmp(clas[0], "BRISKPoints") == 0)
+		{
+			if(count_metric==0 || count_scale==0 || count_orient==0)
+			{
+				Scierror(999,"For BRISKPoints Object \"Metric\" Matrix, \"Orientation\" Matrix and \"Scale\" Matrix are necessary\n");
+				return 0;
+			}
+			if(count_method==0)
+			{
+				method = (char**)malloc(sizeof(char*) * 1 * 1);
+				method[0] = (char*)malloc(sizeof(char) * 6);
+				strcpy(method[0],"FREAK");
+			}
+			for( i=0; i<keypoints.size(); i++)
+			{
+				keypoints[i].response = metric[i];
+				keypoints[i].angle = orient[i];
+			}
+		}
+		else if(strcmp(clas[0], "MSERRegions") == 0)
+		{
+			if(count_orient==0 || count_axes==0)
+			{
+				Scierror(999,"For MSERRegions \"Orientation\" Matrix and \"Axes\" Matrix re necessary.\n");
+				return 0;
+			}
+			if(count_method==0)
+			{
+				method = (char**)malloc(sizeof(char*) * 1 * 1);
+				method[0] = (char*)malloc(sizeof(char) * 5);
+				strcpy(method[0],"SURF");
+			}
+			for( i=0; i<keypoints.size(); i++)
+			{
+				keypoints[i].angle = orient[i];
+			}
+		}
+		else if(strcmp(clas[0], "SURFPoints") == 0)
+		{
+			if(count_scale==0 || count_metric==0 || count_sign==0 || count_orient==0 )
+			{
+				Scierror(999,"For SURFPoints Object \"Metric\" Matrix \"Orientation\" Matrix \"Scale\" Matrix and \"SignOfLaplacian\" Matrix is necessary.\n");
+				return 0;
+			}
+			if(count_method==0)
+			{
+				method = (char**)malloc(sizeof(char*) * 1 * 1);
+				method[0] = (char*)malloc(sizeof(char) * 5);
+				strcpy(method[0],"SURF");
+			}
+			for( i=0; i<keypoints.size(); i++)
+			{
+				keypoints[i].response = metric[i];
+				keypoints[i].angle = orient[i];
+			}
+		}
+		else if(strcmp(clas[0], "Matrix") == 0)
+		{
+			if(count_block==0)
+			{
+				Scierror(999,"For Matirx Object \"BlockSize\" argument is necessary.\n");
+				return 0;
+			}
+			if(count_method==0)
+			{
+				method = (char**)malloc(sizeof(char*) * 1 * 1);
+				method[0] = (char*)malloc(sizeof(char) * 6);
+				strcpy(method[0],"Block");
+			}
+		}
+		else 
+		{
+			Scierror(999,"Provide a Valid Class object\n");
+			return 0;
+		}
+				
+
+
+
+		//All Input Checks has been completed.
+		//.........................................................................................................................................................................................
+		//Processing....
+		
+		Mat descriptor;
+		
+
+		//FREAK
+		if(strcmp(method[0], "FREAK")==0)
+		{	
+			FREAK obj( int(upright), 1, 22.0f, 4 );
+
+			obj.compute(image, keypoints, descriptor);
+			numBits = descriptor.size[1];
+			numFeatures = descriptor.size[0];
+			
+			valid_points = (double *)malloc(sizeof(double) * keypoints.size() * 2); 
+
+			for( int i=0; i<keypoints.size(); i++)
+			{
+				valid_points[i] = keypoints[i].pt.x;
+				valid_points[keypoints.size() + i] = keypoints[i].pt.y;
+			}
+		
+			featureVector = (double*)malloc(sizeof(double)*descriptor.size[0]*descriptor.size[1]);
+			for( int i=0; i<descriptor.size[0]; i++)
+				for( int j=0; j<descriptor.size[1]; j++)
+				{
+					*(featureVector + j*descriptor.size[0] + i) = int( descriptor.at<uchar>(i,j));
+				}
+			feature_rows = descriptor.size[0];
+			feature_cols = descriptor.size[1];
+			valid_rows = descriptor.size[0];
+			count = descriptor.size[0];
+			
+			if( strcmp(clas[0],"cornerPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+			}
+			else if(strcmp(clas[0],"BRISKPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"MSERRegions") == 0)
+			{
+				axes_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						axes_o[iterator] = axes[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"SURFPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+
+				sign_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						sign_o[iterator] = sign[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+			}	
+		}
+
+		//..........................................................................................................................................................................................
+		//SURF
+		else if(strcmp(method[0], "SURF")==0)
+		{
+			SURF obj;
+			if( int(upright) == 1)
+			{
+				if( int(surf_size) == 64)
+					obj = SURF(100, 4, 3, 0, 1);
+				else if ( int(surf_size) == 128)
+					obj = SURF(100, 4, 3, 1, 1); 
+			}
+			else if( int(upright) == 0)
+			{
+				if( int(surf_size) == 64)
+					obj = SURF(100, 4, 3, 0, 0);
+				else if ( int(surf_size) == 128)
+					obj = SURF(100, 4, 3, 1, 0); 
+			}			
+
+			obj.compute(image, keypoints, descriptor);
+			numBits = descriptor.size[1];
+			numFeatures = descriptor.size[0];
+			
+			valid_points = (double *)malloc(sizeof(double) * keypoints.size() * 2); 
+
+			for( int i=0; i<keypoints.size(); i++)
+			{
+				valid_points[i] = keypoints[i].pt.x;
+				valid_points[keypoints.size() + i] = keypoints[i].pt.y;
+			}
+		
+			featureVector = (double*)malloc(sizeof(double)*descriptor.size[0]*descriptor.size[1]);
+			for( int i=0; i<descriptor.size[0]; i++)
+				for( int j=0; j<descriptor.size[1]; j++)
+				{
+					*(featureVector + j*descriptor.size[0] + i) = int( descriptor.at<uchar>(i,j));
+				}
+			feature_rows = descriptor.size[0];
+			feature_cols = descriptor.size[1];
+			valid_rows = descriptor.size[0];
+			count = descriptor.size[0];
+
+			if( strcmp(clas[0],"cornerPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}	
+					if(iterator == keypoints.size())
+						break;				
+				}
+			}
+			else if(strcmp(clas[0],"BRISKPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"MSERRegions") == 0)
+			{
+				axes_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						axes_o[iterator] = axes[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}	
+			}
+			else if(strcmp(clas[0],"SURFPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+
+				sign_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						sign_o[iterator] = sign[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+			}
+		}
+
+		//.........................................................................................................................................................................................
+		//BRISK
+		else if(strcmp(method[0], "BRISK")==0)
+		{
+			BRISK obj;
+			
+			obj.compute(image, keypoints, descriptor);
+			numBits = descriptor.size[1];
+			numFeatures = descriptor.size[0]; 
+
+			valid_points = (double *)malloc(sizeof(double) * keypoints.size() * 2); 
+
+			for( int i=0; i<keypoints.size(); i++)
+			{
+				valid_points[i] = keypoints[i].pt.x;
+				valid_points[keypoints.size() + i] = keypoints[i].pt.y;
+			}
+		
+			featureVector = (double*)malloc(sizeof(double)*descriptor.size[0]*descriptor.size[1]);
+			for( int i=0; i<descriptor.size[0]; i++)
+				for( int j=0; j<descriptor.size[1]; j++)
+				{
+					*(featureVector + j*descriptor.size[0] + i) = int( descriptor.at<uchar>(i,j));
+				}
+			feature_rows = descriptor.size[0];
+			feature_cols = descriptor.size[1];
+			valid_rows = descriptor.size[0];
+			count = descriptor.size[0];
+	
+			if( strcmp(clas[0],"cornerPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+			}
+			else if(strcmp(clas[0],"BRISKPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"MSERRegions") == 0)
+			{
+				axes_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						axes_o[iterator] = axes[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"SURFPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+				
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+
+				sign_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						sign_o[iterator] = sign[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+			}
+		}
+
+		//.........................................................................................................................................................................................
+		//Block
+		else if(strcmp(method[0], "Block")==0)
+		{
+			vector <KeyPoint> valid;
+			for( i=0; i<keypoints.size(); i++)
+			{
+				if( keypoints[i].pt.x - (block_size-1)/2 < 0 || keypoints[i].pt.y - (block_size-1)/2 < 0)
+					continue;
+				if( keypoints[i].pt.x + (block_size-1)/2 > image.cols || keypoints[i].pt.y + (block_size-1)/2 > image.rows)
+					continue;
+				valid.push_back(keypoints[i]);
+			}
+			valid_points = (double *)malloc(sizeof(double)*valid.size()*2);
+			featureVector = (double *)malloc(sizeof(double)*valid.size()*int(block_size)*int(block_size));
+			for( int i=0; i<valid.size(); i++)
+			{
+				int iterator = 0;
+				valid_points[i] = valid[i].pt.x;
+				valid_points[valid.size() + i] = valid[i].pt.y;
+				for( int j=int(valid[i].pt.x-(int(block_size/2))); j<=int(valid[i].pt.x+(int(block_size/2))); j++)
+					for( int k=int(valid[i].pt.y-(int(block_size/2))); k<=int(valid[i].pt.y+(int(block_size/2))); k++)
+					{
+						*(featureVector + i*int(block_size)*int(block_size) + iterator) = image.at<uchar>(j,k);
+						iterator = iterator+1;
+					}	
+			}
+			feature_rows = valid.size();
+			feature_cols = int(block_size)*int(block_size);
+			valid_rows = valid.size();
+			numFeatures = valid.size();
+			numBits = int(block_size)*int(block_size);
+			count = valid.size();
+
+			if( strcmp(clas[0],"cornerPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == valid[iterator].pt.x && copy_k[i].pt.y == valid[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}	
+			}
+			else if(strcmp(clas[0],"BRISKPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"MSERRegions") == 0)
+			{
+				axes_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						axes_o[iterator] = axes[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+			}
+			else if(strcmp(clas[0],"SURFPoints") == 0)
+			{
+				metric_o = (double*)malloc(sizeof(double) * valid_rows);
+				int iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						metric_o[iterator] = metric[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				scale_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						scale_o[iterator] = scale[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+
+				orientation_o = (double*)malloc(sizeof(double) * valid_rows);
+				for(int i=0; i<valid_rows; i++)
+				{
+					orientation_o[i] = (keypoints[i].angle * 3.14)/180 ;
+				}
+
+				sign_o = (double*)malloc(sizeof(double) * valid_rows);
+				iterator = 0;
+				for(int i=0; i<copy_k.size(); i++)
+				{
+					if( copy_k[i].pt.x == keypoints[iterator].pt.x && copy_k[i].pt.y == keypoints[iterator].pt.y )
+					{
+						sign_o[iterator] = sign[i];
+						iterator++;
+					}
+					if(iterator == keypoints.size())
+						break;					
+				}
+			}
+		}
+		else
+		{
+			Scierror(999,"Input a valid method\n");
+			return 0;
+		} 
+
+		
+
+		//.........................................................................................................................................................................................
+		//Output Arguments
+		out_params = *getNbOutputArgument(pvApiCtx);
+
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, feature_rows, feature_cols, featureVector);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, valid_rows, 2, valid_points);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+				
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 1, 1, &numBits);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+	
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 4, 1, 1, &numFeatures);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+		AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+		AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+
+		if(strcmp(clas[0],"cornerPoints") == 0)
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, 1, 1, &count);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 6, valid_rows, 1, metric_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
+		}
+		else if(strcmp(clas[0],"BRISKPoints") == 0)
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, valid_rows, 1, scale_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+		
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 6, valid_rows, 1, metric_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
+			
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 7, valid_rows, 1, orientation_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 7) = nbInputArgument(pvApiCtx) + 7;
+		
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 8, 1, 1, &count);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 8) = nbInputArgument(pvApiCtx) + 8;
+		}
+		else if(strcmp(clas[0],"MSERRegions") == 0)
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, 1, 1, &count);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+		
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 6, valid_rows, 1, axes_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
+			
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 7, valid_rows, 1, orientation_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 7) = nbInputArgument(pvApiCtx) + 7;
+		}
+		else if(strcmp(clas[0],"SURFPoints") == 0)
+		{
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 5, 1, 1, &count);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+		
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 6, valid_rows, 1, scale_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
+			
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 7, valid_rows, 1, metric_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 7) = nbInputArgument(pvApiCtx) + 7;
+
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 8, valid_rows, 1, sign_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 8) = nbInputArgument(pvApiCtx) + 8;
+
+			sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 9, valid_rows, 1, orientation_o);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			AssignOutputVariable(pvApiCtx, 9) = nbInputArgument(pvApiCtx) + 9;
+		}
+
+		free(valid_points);
+		free(featureVector);
+		
+		ReturnArguments(pvApiCtx);
+
+		return 0;
+	}
+}
diff --git a/sci_gateway1/cpp/opencv_extractHOGFeatures.cpp b/sci_gateway1/cpp/opencv_extractHOGFeatures.cpp
new file mode 100644
index 0000000..ad22814
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_extractHOGFeatures.cpp
@@ -0,0 +1,399 @@
+/*******************************************************************************************************************
+              Author : Kevin George
+
+-> Syntax-  extractHOGFeatures("cellsize",..., "BlockSize",...,
+                                "BlockOverlap",..., "NumBins",...)
+
+-> NumBins is strictly of integer type
+********************************************************************************************************************/
+#include <numeric>
+#include <string.h>
+#include <math.h>
+#include <iostream>
+#include <bits/stdc++.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <opencv2/objdetect/objdetect.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"
+
+    int opencv_extractHOGFeatures(char *fname, unsigned long fname_len)
+    {
+
+      	//Error variables
+      	SciErr sciErr;
+      	int intErr = 0;
+
+        //-> Mat containers for images
+        Mat img;
+        Mat img_gray;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+        //int *piAddr2 = NULL;
+
+        //-> Local variables
+        int num_InputArgs;  //-> gives total number of arguments
+        int iRows, iCols;
+        int featureVector_size;
+        int *piLen = NULL;
+        char **pstData = NULL;  //-> why double pointer?? and what is it
+        char *currentArg = NULL; //-> Stores current string representing 'name' of name,value pair arguments
+        bool *providedArgs = NULL; //-> Used to check that optional argument is not entered more than once
+        double *featureVector;
+        //-> Name,Value pair variables
+            double *CellSize = NULL; //->
+            double *BlockSize = NULL; //->
+            double *BlockOverlap = NULL; //->  
+            /*Size CellSize ; //->
+            Size BlockSize ; //->
+            Size BlockOverlap ; //->    */ 
+
+            int NumBins = 9; //-> In docs, it must be int type
+           //vector< int> CellSize; CellSize.push_back(8); CellSize.push_back(8);
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        //-> Checks number of input and output arguments
+        CheckInputArgument(pvApiCtx, 1, 5);                     
+        CheckOutputArgument(pvApiCtx, 1, 5);                    
+
+        //-> Read Image
+        retrieveImage( img, 1);
+
+        //-> Count number of input arguments
+        num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        providedArgs = (bool*) malloc(sizeof(bool) * 5);
+        
+        //-> Based on number of input arguments
+
+//************************************************************  Optional Input Arguments  ************************************************* 
+         vector<KeyPoint> Points;
+
+//************************************************  Retrieval of Name, Value Argument Pair *************************************************
+         for(int iter = 2; iter<= num_InputArgs; iter++)
+         {
+            //-> Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            //-> Extracting name of next argument takes three calls to getMatrixOfString
+            //-> First call to get rows and columns
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+            //-> Second call to retrieve length of each string
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+
+            //-> Third call to retrieve data
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            currentArg = pstData[0];
+            free(pstData);
+            iRows=0;
+            iCols=0;
+            free(piLen);
+
+//****************************************************** Name,Value - Cellsize *****************************************************************
+            if(strcmp(currentArg, "CellSize")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &CellSize); 
+                    if(sciErr.iErr)
+                    {
+                      printError(&sciErr, 0);
+                      return 0;
+                    }
+
+                    if(iRows*iCols!=2)
+                    {   
+                      Scierror(999,"Invalid Argument\n");
+                      return 0;
+                    }
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                     if(CellSize[0]<0 || CellSize[1]<0)
+                     {   
+                       sciprint("Arguments cannot be negative\n");
+                       return 0;
+                     }
+
+                    providedArgs[0] = 1; 
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+//************************************** Name,Value - BlockSize ************************************          
+            else if(strcmp(currentArg, "BlockSize")==0)
+            {
+              if(iter+1<= num_InputArgs && !providedArgs[1])
+              {
+                   sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                   if (sciErr.iErr)
+                   {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                   }
+
+                   sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &BlockSize); 
+                   if(sciErr.iErr)
+                   {
+                      printError(&sciErr, 0);
+                      return 0;
+                    }
+
+                   if(iRows*iCols!=2)
+                   {   
+                      Scierror(999,"Invalid Argument\n");
+                      return 0;
+                   }
+
+                   //-> Checking if values are in proper range. Same for all optional arguments
+                   if(BlockSize[0]<0 || BlockSize[1]<0)
+                   {   
+                       sciprint("Arguments cannot be negative\n");
+                       return 0;
+                   }
+
+                    providedArgs[1] = 1; 
+              }
+              else if(providedArgs[1]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+              {
+                   Scierror(999, "Please provide optional arguments only once.\n"); 
+                   return 0; 
+              }
+              else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+              {
+                   Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                   return 0; 
+              }
+
+            }
+
+         
+//********************************************* Name,Value - BlockOverlap ************************************************
+            else if(strcmp(currentArg, "BlockOverlap")==0)
+            {
+                 if(iter+1<= num_InputArgs && !providedArgs[2])
+                 {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &BlockOverlap); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 0;
+                     }
+
+                    if(iRows*iCols!=2)
+                    {   
+                        Scierror(999,"Invalid Argument\n");
+                        return 0;
+                    }
+
+                   //-> Checking if values are in proper range. Same for all optional arguments
+                   if(BlockOverlap[0]<0 || BlockOverlap[1]<0)
+                   {   
+                       sciprint("Arguments cannot be negative\n");
+                       return 0;
+                   }
+
+                    providedArgs[2] = 1;     
+                 }
+
+                else if(providedArgs[2]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                   Scierror(999, "Please provide optional arguments only once.\n"); 
+                   return 0; 
+                }
+           
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                   Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                   return 0; 
+                }
+
+
+            }
+//*********************************************** *********** Name,Value - NumBins **********************************************************************  
+            else if(strcmp(currentArg, "NumBins")==0)
+            {
+                 if(iter+1<= num_InputArgs && !providedArgs[3])
+                 {
+                     sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                     if (sciErr.iErr)
+                     {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                     }
+
+                     intErr = getScalarInteger32(pvApiCtx, piAddr, &NumBins); 
+                     if(intErr)
+                     {
+                        return intErr; 
+                     }
+
+                     if( NumBins<= 0)
+                     {
+                        Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values must be more than zero.\n", currentArg); 
+                        return 0; 
+                     }
+                     providedArgs[3] = 1; 
+                 }
+
+                else if(providedArgs[3])
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+          
+          else
+          {
+               Scierror(999, "Incorrect Name type. Please re-enter the correct Name-Value pair arguments\n"); 
+                    return 0;  
+          }
+
+         }//-> Brace for closing for loop
+
+//******************************************************** Giving Default Arguments ******************************************************************* 
+
+        if(providedArgs[0] == 0)
+        {
+            CellSize = (double*) malloc(sizeof(double)*2);
+            CellSize[0] = 8;
+            CellSize[1] = 8;
+        }
+
+
+        if(providedArgs[1] == 0)
+        {
+            BlockSize = (double*) malloc(sizeof(double)*2);
+            BlockSize[0] = 16;
+            BlockSize[1] = 16;
+        }
+
+        if(providedArgs[2] == 0)
+        {
+            BlockOverlap = (double*) malloc(sizeof(double)*2);
+            BlockOverlap[0] = 8;
+            BlockOverlap[1] = 8;
+        }
+
+        if(providedArgs[3] == 0)
+        {
+            NumBins = 9;
+        }
+
+//**************************************************************Actual Processing*******************************************************************************
+
+        //-> resizing
+        //resize(img, img, Size(64,48) ); 
+        resize(img, img, Size(64,128) ); 
+    
+        //-> Convert to grayscale(Necessary Step)
+        cvtColor(img, img_gray, CV_RGB2GRAY);
+
+        //-> CellSize (8,8) is only supported size
+        //   in opencv 2.4.9
+        //HOGDescriptor d( Size(64,128), Size(16,16), Size(8,8), Size(8,8), 9);
+        HOGDescriptor d(Size(64,128), Size(BlockSize[0],BlockSize[1]), Size(BlockOverlap[0],BlockOverlap[1]),Size(CellSize[0],CellSize[1]), NumBins);
+        //-> This is our descriptor vector
+            
+        vector<float> descriptorsValues;
+        vector< Point> locations ;
+        d.compute( img_gray, descriptorsValues, Size(32,32), Size(0,0), locations);
+
+        //-> Displaying feature vector size
+        //sciprint("%d\n",descriptorsValues.size());
+        //for(int i =0; i<descriptorsValues.size();i++)
+          // sciprint("%f\t", descriptorsValues[i]);
+        //cout<< descriptorsValues[i]<< "\t";*/ 
+        //sciprint("%d\n",locations.size());
+
+        featureVector_size = descriptorsValues.size();
+        featureVector = (double*) malloc(sizeof(double)*featureVector_size); //doesn't have floating point
+        for(int i=0; i<featureVector_size; i++)
+        {
+            featureVector[i] = descriptorsValues[i];
+        }
+//************************************************************ Output **************************************************************************
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+1, featureVector_size, 1, featureVector); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        //-> Returning Output
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1; 
+        ReturnArguments(pvApiCtx);
+        return 0;    	
+    }
+
+}   
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_extractLBPFeatures.cpp b/sci_gateway1/cpp/opencv_extractLBPFeatures.cpp
new file mode 100644
index 0000000..291f6bb
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_extractLBPFeatures.cpp
@@ -0,0 +1,515 @@
+/***************************************************
+Author : Tanmay Chaudhari
+
+TO DO:
+1) nearest neighbor interpolation
+2) upright parameter implementation
+ ***************************************************/
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <bits/stdc++.h>
+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"
+//#include "../common.cpp"
+
+	void ELBP(const Mat& src, Mat& dst, int radius, int neighbors) 
+	{
+		neighbors = max(min(neighbors,31),1); // set bounds...
+		// Note: alternatively you can switch to the new OpenCV Mat_
+		// type system to define an unsigned int matrix... I am probably
+		// mistaken here, but I didn't see an unsigned int representation
+		// in OpenCV's classic typesystem...
+		dst = Mat::zeros(src.rows-2*radius, src.cols-2*radius, CV_32SC1);
+		for(int n=0; n<neighbors; n++) 
+		{
+			// sample points
+			float x = static_cast<float>(radius) * cos(2.0*M_PI*n/static_cast<float>(neighbors));
+			float y = static_cast<float>(radius) * -sin(2.0*M_PI*n/static_cast<float>(neighbors));
+			// relative indices
+			int fx = static_cast<int>(floor(x));
+			int fy = static_cast<int>(floor(y));
+			int cx = static_cast<int>(ceil(x));
+			int cy = static_cast<int>(ceil(y));
+			// fractional part
+			float ty = y - fy;
+			float tx = x - fx;
+			// set interpolation weights
+			float w1 = (1 - tx) * (1 - ty);
+			float w2 =      tx  * (1 - ty);
+			float w3 = (1 - tx) *      ty;
+			float w4 =      tx  *      ty;
+			// iterate through your data
+			for(int i=radius; i < src.rows-radius;i++) 
+			{
+				for(int j=radius;j < src.cols-radius;j++) 
+				{
+					float t = w1*src.at<float>(i+fy,j+fx) + w2*src.at<float>(i+fy,j+cx) + w3*src.at<float>(i+cy,j+fx) + w4*src.at<float>(i+cy,j+cx);
+					// we are dealing with floating point precision, so add some little tolerance
+					dst.at<unsigned int>(i-radius,j-radius) += ((t > src.at<float>(i,j)) && (abs(t-src.at<float>(i,j)) > std::numeric_limits<float>::epsilon())) << n;
+				}
+			}
+		}
+	}
+
+	/*void ELBP(const Mat& src, Mat& dst, int radius, int neighbors)
+	{
+		switch(src.type()) {
+			case CV_8SC1: ELBP_<char>(src, dst, radius, neighbors); break;
+			case CV_8UC1: ELBP_<unsigned char>(src, dst, radius, neighbors); break;
+			case CV_16SC1: ELBP_<short>(src, dst, radius, neighbors); break;
+			case CV_16UC1: ELBP_<unsigned short>(src, dst, radius, neighbors); break;
+			case CV_32SC1: ELBP_<int>(src, dst, radius, neighbors); break;
+			case CV_32FC1: ELBP_<float>(src, dst, radius, neighbors); break;
+			case CV_64FC1: ELBP_<double>(src, dst, radius, neighbors); break;
+		}
+	}*/
+
+	static Mat histc_(const Mat& src, int minVal=0, int maxVal=255, bool normed=false)
+	{
+		Mat result;
+		// Establish the number of bins.
+		int histSize = maxVal-minVal+1;
+		// Set the ranges.
+		float range[] = { static_cast<float>(minVal), static_cast<float>(maxVal+1) };
+		const float* histRange = { range };
+		// calc histogram
+		calcHist(&src, 1, 0, Mat(), result, 1, &histSize, &histRange, true, false);
+		// normalize
+		if(normed) {
+			result /= (int)src.total();
+		}
+		return result.reshape(1,1);
+	}
+
+	static Mat histc(InputArray _src, int minVal, int maxVal, bool normed)
+	{
+		Mat src = _src.getMat();
+		switch (src.type()) {
+			case CV_8SC1:
+				return histc_(Mat_<float>(src), minVal, maxVal, normed);
+				break;
+			case CV_8UC1:
+				return histc_(src, minVal, maxVal, normed);
+				break;
+			case CV_16SC1:
+				return histc_(Mat_<float>(src), minVal, maxVal, normed);
+				break;
+			case CV_16UC1:
+				return histc_(src, minVal, maxVal, normed);
+				break;
+			case CV_32SC1:
+				return histc_(Mat_<float>(src), minVal, maxVal, normed);
+				break;
+			case CV_32FC1:
+				return histc_(src, minVal, maxVal, normed);
+				break;
+		}
+		return Mat();
+	}
+
+
+	static Mat spatial_histogram(InputArray _src, int numPatterns, int grid_x, int grid_y, bool normed)
+	{
+		Mat src = _src.getMat();
+		// calculate LBP patch size
+		//int width = src.cols/grid_x;
+		//int height = src.rows/grid_y;
+		int width = grid_x;
+		int height = grid_y;
+
+		// allocate memory for the spatial histogram
+		Mat result = Mat::zeros(grid_x * grid_y, numPatterns, CV_32FC1);
+		// return matrix with zeros if no data was given
+		if(src.empty())
+			return result.reshape(1,1);
+		// initial result_row
+		int resultRowIdx = 0;
+		// iterate through grid
+		for(int i = 0; i < grid_y; i++) {
+			for(int j = 0; j < grid_x; j++) {
+				Mat src_cell = Mat(src, Range(i*height,(i+1)*height), Range(j*width,(j+1)*width));
+				Mat cell_hist = histc(src_cell, 0, (numPatterns-1), normed);
+				// copy to the result matrix
+				Mat result_row = result.row(resultRowIdx);
+				cell_hist.reshape(1,1).convertTo(result_row, CV_32FC1);
+				// increase row count in result matrix
+				resultRowIdx++;
+			}
+		}
+		// return result as reshaped feature vector
+		return result.reshape(1,1);
+	}
+
+	int opencv_extractLBPFeatures(char *fname, unsigned long fname_len)
+	{
+		//Error management variable
+		SciErr sciErr;
+
+		//Variable declaration
+		int iRows = 0;
+		int iCols = 0;
+		int intErr = 0;
+		int nbInputArguments = 0;
+		int *piLen = NULL;
+		int *piAddr = NULL;
+		bool *providedArgs = NULL; 
+		bool linearInterpolation = 1;
+		bool normalization = 1;
+		char *currentArg = NULL; 
+		char **pstData  = NULL;
+		double radius = 1;
+		double upright = 1;
+		double neighbors = 8;
+		double *cellSize = NULL;
+		double *outputHist = NULL;
+		Mat image;
+		Mat grayscaleImage;
+		Mat lbpImage;
+		Mat spatialHistogram;
+
+		//Check input output arguments
+		CheckInputArgument(pvApiCtx, 1, 13);
+		CheckOutputArgument(pvApiCtx, 1, 1);
+
+		nbInputArguments = *getNbInputArgument(pvApiCtx);
+
+		if((nbInputArguments-1)%2!=0)
+		{
+			Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+			return 0; 
+		}
+
+		providedArgs = (bool*)malloc(sizeof(bool) * 6);
+		for(int i=0;i<6;i++)
+			providedArgs[i] = 0;
+
+		//getting input arguments
+		retrieveImage(image, 1); 
+		cellSize = (double*)malloc(sizeof(double) * 2);
+
+		for(int iter=2;iter<=nbInputArguments;iter++)
+		{
+			// Getting address of next argument
+			sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			// Extracting name of next argument takes three calls to getMatrixOfString
+			sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+			sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+			for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+			{
+				pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+			}
+
+			sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+			if (sciErr.iErr)
+			{
+				printError(&sciErr, 0); 
+				return 0; 
+			}
+
+			currentArg = pstData[0];
+			// providedArgs[] makes sure that no optional argument is provided more than once
+
+			if(strcmp(currentArg, "NumNeighbors")==0)
+			{
+				if(!providedArgs[0])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					intErr = getScalarDouble(pvApiCtx, piAddr, &neighbors); 
+					if(intErr)
+					{
+						return intErr;  
+					}
+					// Checking if values are in proper range. Same for all optional arguments
+					if(neighbors < 4 || neighbors > 24)
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible range is [4, 24].\n", currentArg); 
+						return 0; 
+					}	
+					providedArgs[0] = 1;
+
+				}
+				else if(providedArgs[0])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+			else if(strcmp(currentArg, "Radius")==0)
+			{
+				if(!providedArgs[1])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					intErr = getScalarDouble(pvApiCtx, piAddr, &radius); 
+					if(intErr)
+					{
+						return intErr;  
+					}
+					// Checking if values are in proper range. Same for all optional arguments
+					if(radius < 1 || radius > 5)
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible range is [1, 5].\n", currentArg); 
+						return 0; 
+					}
+					providedArgs[1] = 1;
+				}
+				else if(providedArgs[1])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+			else if(strcmp(currentArg, "Upright")==0)
+			{
+				if(!providedArgs[2])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					intErr = getScalarDouble(pvApiCtx, piAddr, &upright); 
+					if(intErr)
+					{
+						return intErr;  
+					}
+					// Checking if values are in proper range. Same for all optional arguments
+					if(upright!=0.0 && upright!=1.0)
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are 0 or 1.\n", currentArg); 
+						return 0; 
+					}
+					providedArgs[2] = 1;
+				}
+				else if(providedArgs[2])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+			else if(strcmp(currentArg, "Interpolation")==0)
+			{
+				if(!providedArgs[3])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+					sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+					for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+					{
+						pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					if(strcmp(pstData[0],"Mean square error")==0)
+						linearInterpolation=1;
+					else if(strcmp(pstData[0], "Nearest")==0)
+						linearInterpolation=0;
+					else
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are Linear or Nearest.\n", currentArg); 
+						return 0; 
+					}
+					providedArgs[3]=1;
+				}
+				else if(providedArgs[3])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}	
+			}
+			else if(strcmp(currentArg, "CellSize")==0)
+			{
+				if(!providedArgs[4])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+					{
+						Scierror(999, "%s: Wrong type for input argument #%d: A real matrix expected.\n", fname, iter); 
+						return 0; 
+					}
+					sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &cellSize); 
+					if(sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+					if(iRows!=1 || iCols!=2)
+					{
+						Scierror(999, "Incorrect dimension of matrix for argument CellSize.\n"); 
+						return 0; 
+					}
+					providedArgs[4]=1;
+				}
+				else if(providedArgs[4])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+			else if(strcmp(currentArg, "Normalization")==0)
+			{
+				if(!providedArgs[5])
+				{
+					sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+					sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+					for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+					{
+						pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+					}
+
+					sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+					if (sciErr.iErr)
+					{
+						printError(&sciErr, 0); 
+						return 0; 
+					}
+
+					if(strcmp(pstData[0],"L2")==0)
+						normalization=1;
+					else if(strcmp(pstData[0], "None")==0)
+						normalization=0;
+					else
+					{
+						Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are L2 or None.\n", currentArg); 
+						return 0; 
+					}
+					providedArgs[5]=1;
+				}
+				else if(providedArgs[5])
+				{
+					Scierror(999, "Please provide optional arguments only once.\n"); 
+					return 0; 
+				}
+			}
+		}
+		//onvert RGB image to gray
+		cvtColor(image, grayscaleImage, CV_BGR2GRAY);
+		ELBP(grayscaleImage, lbpImage, radius, neighbors);
+
+		if(!providedArgs[4])
+		{
+			cellSize[0] = lbpImage.cols;
+			cellSize[1] = lbpImage.rows;
+		}
+
+		//calculate the spatial histogram
+		spatialHistogram = spatial_histogram(lbpImage, static_cast<int>(pow(2.0, static_cast<double>(neighbors))), int(cellSize[0]), int(cellSize[1]), normalization);
+		
+		outputHist = (double*)malloc(sizeof(double) * spatialHistogram.cols);
+		for(int i=0;i<spatialHistogram.cols;i++)
+			outputHist[i] = spatialHistogram.at<double>(0,i);	
+
+		//create output argument
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx)+1, 1, spatialHistogram.cols, outputHist); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+		//return output Arguments
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+	/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_fillconvexpoly.cpp b/sci_gateway1/cpp/opencv_fillconvexpoly.cpp
new file mode 100644
index 0000000..1ce29c6
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_fillconvexpoly.cpp
@@ -0,0 +1,173 @@
+/*************************************************
+Authors : Abhilasha Sancheti & Sukul Bagai
+**************************************************
+ sample inputs : b=fillconvexpoly(a,points,4,0,0,0,8,0);       (points: [0 0;0 100;100 0; 100 100])
+ fillConvexpoly( image , points , r_value , g_value , b_value , linrtype,shift);
+*************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_fillconvexpoly(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int i,j,k ;
+    double *pstData = NULL;
+    double npts ,r_value,g_value ,b_value ,linetype=8 ,shift=0;
+    
+ 
+   
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 8, 8);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    
+//retreive the value of clockwise parameter 
+    Mat image;
+    retrieveImage(image,1);
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &pstData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    } 
+///// store values in a contour
+    
+    Point *pts = (Point *)malloc(iRows * 2 * sizeof(double));
+    for ( i = 0 ; i < iRows ; i++)
+    {
+          pts[i].x = *(pstData + i);
+          pts[i].y = *(pstData + 1*iRows + i);
+    }
+   
+  /// to retrieve the number of points         
+     sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &npts);
+    if(intErr)
+    {
+       return intErr;
+    } 
+       
+//// to retreive the value of r_value
+        sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &r_value);
+    if(intErr)
+    {
+       return intErr;
+    } 
+ /// to retreive the value of g_value
+        sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr5, &g_value);
+    if(intErr)
+    {
+       return intErr;
+    } 
+  
+  /// to retreive the value of b_value
+        sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr6, &b_value);
+    if(intErr)
+    {
+       return intErr;
+    } 
+  /// to retreive the value of linetype
+        sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7, &linetype);
+    if(intErr)
+    {
+       return intErr;
+    } 
+/// to retreive the value of shift
+        sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8, &shift);
+    if(intErr)
+    {
+       return intErr;
+    } 
+    
+   
+
+	 // call the fillconvexpoly function of opencv
+    fillConvexPoly(image,pts,npts,Scalar(r_value,g_value,b_value),linetype,shift);
+   
+     //temp variable was not needed, hence has been discarded
+    string tempstring = type2str(image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,image,1); //here, remove the temp as a parameter as it is not needed, and instead add 1 as the third parameter. 1 denotes that the first output       argument will be this variable
+    free(checker); //free memory taken up by checker
+
+ 
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
diff --git a/sci_gateway1/cpp/opencv_filter2D.cpp b/sci_gateway1/cpp/opencv_filter2D.cpp
new file mode 100644
index 0000000..650771b
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_filter2D.cpp
@@ -0,0 +1,184 @@
+/***************************************************
+Author : Sukul Bagai
+****************************************************
+Usage : return_image = filter2D(input_image,"<ddepth>",kernel_matrix,anchor_x,anchor_y,delta);
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_filter2D(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    char **ddepth = NULL;
+    int i,j,k;
+    double *kernel,anchorX,anchorY,delta;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for ddepth
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    ddepth = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        ddepth[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, ddepth);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for kernel matrix
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols ,&kernel);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+
+    int n=iRows;
+    double kernelArray[n][n];
+    //assigning values to actual kernelMatrix
+    for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+            kernelArray[i][j]=kernel[(i*n)+j];
+    // converting the array to a matrix, so that we can pass it into the filter2D function    
+    Mat kernelMatrix(n, n, CV_32FC1, &kernelArray);
+
+    //for value of anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &anchorX);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &anchorY);
+    if(intErr)
+        return intErr;
+
+    //for value of delta
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &delta);
+    if(intErr)
+        return intErr;
+
+    //error check
+    if(anchorX >= n || anchorY >=n)
+    {
+        sciprint("Invalid anchor point given. Centre point (-1,-1) was used instead");
+        anchorY = -1;
+        anchorX = -1;
+    }
+    Mat new_image(image.rows,image.cols,image.type());
+    Point pt(anchorX,anchorY);
+
+    int actualddepth;
+
+    if(strcmp(ddepth[0],"CV_8U")==0)
+        actualddepth=CV_8U;
+    else if(strcmp(ddepth[0],"CV_16U")==0)
+        actualddepth=CV_16U;
+    else if(strcmp(ddepth[0],"CV_16S")==0)
+        actualddepth=CV_16S;
+    else if(strcmp(ddepth[0],"CV_32F")==0)
+        actualddepth=CV_32F;
+    else if(strcmp(ddepth[0],"CV_64F")==0)
+        actualddepth=CV_64F;
+    else
+    {
+        sciprint("Invalid type %s used. CV_8U was used instead by default",ddepth[0]);
+        actualddepth = CV_8U;
+    }
+
+    //applying function
+    filter2D(image,new_image,actualddepth,kernelMatrix,pt,delta);
+
+    //returning image
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+    
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_findContours.cpp b/sci_gateway1/cpp/opencv_findContours.cpp
new file mode 100644
index 0000000..05da2b3
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_findContours.cpp
@@ -0,0 +1,199 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   contours = findcontours(input_image(after canny is applied on it), mode, method, point_x, point_y)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_findContours(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen2=NULL;
+    int *piLen3 = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k, findmode , findmethod;
+    char **find_method=NULL , **mode = NULL;
+    double x,y;
+   
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    
+    Mat src;
+    retrieveImage(src,1);
+       
+    // for mode parameter of findContours
+     sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+             //checking for error if any
+     if (sciErr.iErr)
+     {
+      printError(&sciErr, 0);
+      return 0;
+     }
+     sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, NULL, NULL);
+     piLen2 = (int*)malloc(sizeof(int) * iRows * iCols);
+     //second call to retrieve length of each string of first argument
+     sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen2, NULL);
+     if(sciErr.iErr)
+     {
+        printError(&sciErr, 0);
+        return 0;
+     }
+     mode= (char**)malloc(sizeof(char*) * iRows * iCols);
+     for(i = 0 ; i < iRows * iCols ; i++)
+     {
+         mode[i] = (char*)malloc(sizeof(char) * (piLen2[i] + 1));//+ 1 for null termination
+     }
+     //third call to retrieve data of each string of first argument
+     sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen2, mode);
+     if(sciErr.iErr)
+     {
+        printError(&sciErr, 0);
+        return 0;
+     }  
+
+     // for method parameter of findContours
+      sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+             //checking for error if any
+       if (sciErr.iErr)
+       {
+        printError(&sciErr, 0);
+        return 0;
+       }
+       sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, NULL, NULL);
+       piLen3 = (int*)malloc(sizeof(int) * iRows * iCols);
+       //second call to retrieve length of each string of first argument
+       sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen3, NULL);
+       if(sciErr.iErr)
+       {
+          printError(&sciErr, 0);
+          return 0;
+       }
+       find_method= (char**)malloc(sizeof(char*) * iRows * iCols);
+       for(i = 0 ; i < iRows * iCols ; i++)
+       {
+           find_method[i] = (char*)malloc(sizeof(char) * (piLen3[i] + 1));//+ 1 for null termination
+       }
+       //third call to retrieve data of each string of first argument
+       sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen3, find_method);
+       if(sciErr.iErr)
+       {
+          printError(&sciErr, 0);
+          return 0;
+       }
+       //toget the x coordinate of point parameter of findcontours
+        sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&x);
+    if(intErr)
+       return intErr;
+  
+           //toget the y coordinate of point parameter of findcontours
+        sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&y);
+    if(intErr)
+       return intErr;
+     
+       //to set hte mode for findcontour
+       if (strcmp(mode[0],"CV_RETR_EXTERNAL")==0)
+            findmode = CV_RETR_EXTERNAL;
+        else if (strcmp(mode[0],"CV_RETR_LIST")==0)
+          findmode =  CV_RETR_LIST;
+        else if (strcmp(mode[0],"CV_RETR_CCOMP")==0)
+          findmode =  CV_RETR_CCOMP;
+        else if (strcmp(mode[0],"CV_RETR_TREE")==0)
+            findmode =  CV_RETR_TREE;
+        else
+           {
+              findmode =  CV_RETR_TREE;
+              sciprint("wrong mode given , using CV_RETR_TREE instead");
+           }
+        // to set the method for findContours
+       if (strcmp(find_method[0],"CV_CHAIN_APPROX_NONE")==0)
+            findmethod = CV_CHAIN_APPROX_NONE;
+        else if (strcmp(  find_method[0],"CV_CHAIN_APPROX_SIMPLE")==0)
+          findmethod =  CV_CHAIN_APPROX_SIMPLE;
+        else if (strcmp(find_method[0],"CV_CHAIN_APPROX_TC89_L1")==0)
+          findmethod =  CV_CHAIN_APPROX_TC89_L1;
+        else if (strcmp(find_method[0],"CV_CHAIN_APPROX_TC89_KCOS")==0)
+            findmethod =  CV_CHAIN_APPROX_TC89_KCOS;       
+        else
+           {
+              findmethod =  CV_CHAIN_APPROX_SIMPLE;
+              sciprint("wrong method given , using CV_CHAIN_APPROX_SIMPLE instead");
+           }
+    Point pt(x,y);
+    /// Find contours  
+    vector<vector<Point> > contours;
+    vector<Vec4i> hierarchy;
+    findContours( src, contours, hierarchy, findmode, findmethod, pt);
+
+    //Assigning the list as the Output Variable
+    sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, contours.size(), &piAddrNew);
+    if(sciErr.iErr)
+    {
+       printError(&sciErr, 0);           
+       return 0;
+    }
+
+    for(i=0;i<contours.size();i++)
+    {
+        double *arr = (double *)malloc(sizeof(double) * 2 * contours[i].size());
+
+        for(j=0;j<contours[i].size();j++)
+        {
+            *(arr + j*2 + 0) = contours[i][j].x;
+            *(arr + j*2 + 1) = contours[i][j].y;
+        }
+
+        sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+1 , piAddrNew, i+1, contours[i].size(), 2, arr);
+        free(arr);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+    }
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
diff --git a/sci_gateway1/cpp/opencv_gaussianblur.cpp b/sci_gateway1/cpp/opencv_gaussianblur.cpp
new file mode 100644
index 0000000..f81885e
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_gaussianblur.cpp
@@ -0,0 +1,132 @@
+/***************************************************
+Author : Sukul Bagai
+****************************************************
+Usage : return_image = gaussianblur(input_image,ksize_height,ksize_width,sigmaX,sigmaY);
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_gaussianblur(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k;
+    double ksize_width,ksize_height,sigmaX,sigmaY;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for value of ksize_height
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &ksize_height);
+    if(intErr)
+        return intErr;
+
+    //for value of ksize_width
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &ksize_width);
+    if(intErr)
+        return intErr;
+
+    //for value of sigmaX
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &sigmaX);
+    if(intErr)
+        return intErr;
+
+    //for value of sigmaY
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &sigmaY);
+    if(intErr)
+        return intErr;
+
+    //applying checks to input parameters, and assigning default values in case of error
+    Mat new_image(image.rows,image.cols,CV_8UC3);
+    if(ksize_height<0)
+    {
+        sciprint("Positive Value Required for Height. 1 value was used instead");
+        ksize_height=1;
+    }
+    if(ksize_width<0)
+    {
+        sciprint("Positive Value Required for Width. 1 value was used instead");
+        ksize_width=1;
+    }
+    if((int)ksize_height%2==0)
+    {
+        ksize_height+=1;
+        sciprint("Odd Value Required for Height. %f value was used instead",&ksize_height);
+    }
+    if((int)ksize_width%2==0)
+    {
+        ksize_width+=1;
+        sciprint("Odd Value Required for Width. %f value was used instead",&ksize_width);
+    }
+
+    //temporary size variable, to use in function
+    Size sz(ksize_height,ksize_width);
+
+    //void GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT )
+    GaussianBlur(image,new_image,sz,sigmaX,sigmaY);
+
+    //returning image
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_generateCheckerboardPoints.cpp b/sci_gateway1/cpp/opencv_generateCheckerboardPoints.cpp
new file mode 100644
index 0000000..998f6fe
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_generateCheckerboardPoints.cpp
@@ -0,0 +1,157 @@
+/***************************************************
+Author : Tanmay Chaudhari
+ **************************************************/
+
+#include <numeric>
+#include <iostream>
+using namespace std;
+extern "C"
+{
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "BOOL.h"
+#include <localization.h>
+#include "sciprint.h"
+
+	int opencv_genCheckerboardPoints(char *fname, unsigned long fname_len)
+	{
+		//Error management variable
+		SciErr sciErr;
+
+		//Variable declaration
+		int iType = 0;
+		int iComplex = 0;
+		int rowsOfBoardSize = 0;
+		int rowsOfSquareSize = 0;
+		int colsOfBoardSize = 0;
+		int colsOfSquareSize = 0;
+		int iterator1 = 0;
+		int iterator2 = 0;
+		int *piAddr = NULL;
+		double *boardSize = NULL;
+		double *squareSize = NULL;
+		double *worldPoints = NULL;
+
+		//Check input output arguments
+		checkInputArgument(pvApiCtx, 2, 2);
+		checkOutputArgument(pvApiCtx, 1, 1);
+
+		//Get variable address of the first input argument
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{	
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfBoardSize, &colsOfBoardSize, &boardSize);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		if(((rowsOfBoardSize != 1) || (colsOfBoardSize != 2)) || (boardSize[0] <= 0) || (boardSize[1] <= 0))
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}	
+
+		//Get variable address of the second input argument
+		sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+		if(sciErr.iErr)
+		{	
+			printError(&sciErr, 0);
+			return 0;
+		}
+		
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+		
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfSquareSize, &colsOfSquareSize, &squareSize);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		
+		if(((rowsOfSquareSize != 1) || (colsOfSquareSize != 1)) || (squareSize[0] <= 0))
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		boardSize[0] -= 1;
+		boardSize[1] -= 1;
+		worldPoints = (double*)malloc(sizeof(double) * 2 * (int(boardSize[0])) * (int(boardSize[1])));
+
+		iterator1 = 0;
+		iterator2 = (int(boardSize[0])) * (int(boardSize[1]));
+
+		for(int j = 0; j <= int(boardSize[1]) - 1; j++)
+		{
+			for(int i = 0; i <= int(boardSize[0]) - 1; i++)
+			{
+				worldPoints[iterator1] = j * squareSize[0];
+				worldPoints[iterator2] = i * squareSize[0];
+				iterator1++;
+				iterator2++;
+			}
+		}
+
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, (int(boardSize[0])) * (int(boardSize[1])), 2, worldPoints);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Return Output Argument
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
+
+
+
diff --git a/sci_gateway1/cpp/opencv_getStructuringElement.cpp b/sci_gateway1/cpp/opencv_getStructuringElement.cpp
new file mode 100644
index 0000000..8226671
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_getStructuringElement.cpp
@@ -0,0 +1,147 @@
+/*************************************************
+Author: Sukul Bagai
+**************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+  int opencv_getStructuringElement(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr1 = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k,type;
+    char **gettype = NULL;
+    double cols,rows,anchorX,anchorY;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr1);      
+    //checking for error if any
+    if (sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = getMatrixOfString(pvApiCtx, piAddr1, &iRows, &iCols, NULL, NULL);
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string of first argument
+    sciErr = getMatrixOfString(pvApiCtx, piAddr1, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    gettype= (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+         gettype[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+   //third call to retrieve data of each string of first argument
+    sciErr = getMatrixOfString(pvApiCtx, piAddr1, &iRows, &iCols, piLen, gettype);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    
+    if(strcmp("MORPH_RECT",gettype[0])==0)
+      type=MORPH_RECT;
+    else if(strcmp("MORPH_ELLIPSE",gettype[0])==0)
+      type=MORPH_ELLIPSE;
+    else if(strcmp("MORPH_CROSS",gettype[0])==0)
+      type=MORPH_CROSS;
+
+    //for cols
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0; 
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2 ,&cols);
+    if(intErr)
+        return intErr;
+
+    //for rows
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0; 
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &rows);
+    if(intErr)
+        return intErr;
+
+    //for anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0; 
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4 ,&anchorX);
+    if(intErr)
+        return intErr;
+
+    //for anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0; 
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&anchorY);
+    if(intErr)
+        return intErr;
+
+    Mat temp = getStructuringElement(type,Size(rows,cols),Point(anchorX,anchorY));
+
+    double *m = (double *)malloc(temp.rows*temp.cols*sizeof(double));
+    for(i=0;i<temp.rows;i++)
+    {
+      for(j=0;j<temp.cols;j++)
+      {
+        uchar intensity = temp.at<uchar>(i, j);
+        *(m + i*temp.cols + j) = intensity;
+      }
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, temp.rows, temp.cols, m);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
diff --git a/sci_gateway1/cpp/opencv_getTextSize.cpp b/sci_gateway1/cpp/opencv_getTextSize.cpp
new file mode 100644
index 0000000..150b8ec
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_getTextSize.cpp
@@ -0,0 +1,188 @@
+/***************************************************
+Author : Sukul Bagai , Abhilasha Sancheti
+****************************************************
+Usage : [size,baseline] = getTextSize("<input text>","<fontface>",fontscale,thickness);
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_getTextSize(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piLen = NULL;
+    int *piLen2 = NULL;
+    char **pstData = NULL;
+    char **pstData2 = NULL;
+    double font_scale = 0,thickness = 0;
+    int i;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 2, 2) ;
+
+    //for string
+    sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for fontface
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen2 = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen2, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    pstData2 = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        pstData2[i] = (char*)malloc(sizeof(char) * (piLen2[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen2, pstData2);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for value of font scale
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &font_scale);
+    if(intErr)
+        return intErr;
+
+    //for value of thickness
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &thickness);
+    if(intErr)
+        return intErr;
+
+    int fontFace;
+
+    if(strcmp(pstData2[0],"FONT_HERSHEY_SIMPLEX")==0)
+           fontFace = FONT_HERSHEY_SIMPLEX;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_PLAIN")==0)
+          fontFace= FONT_HERSHEY_PLAIN;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_DUPLEX")==0)
+          fontFace= FONT_HERSHEY_DUPLEX;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_COMPLEX")==0)
+          fontFace= FONT_HERSHEY_COMPLEX;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_TRIPLEX")==0)
+          fontFace = FONT_HERSHEY_TRIPLEX;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_COMPLEX_SMALL")==0)
+          fontFace = FONT_HERSHEY_COMPLEX_SMALL;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_SCRIPT_SIMPLEX")==0)
+         fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
+    else if (strcmp(pstData2[0],"FONT_HERSHEY_SCRIPT_COMPLEX")==0)
+         fontFace = FONT_HERSHEY_SCRIPT_COMPLEX;
+
+    int baseline;
+    Size sz = getTextSize(pstData[0],fontFace,font_scale,thickness,&baseline); 
+    double tempsize[2];
+    tempsize[0]=sz.width;
+    tempsize[1]=sz.height;
+    double returnbaseline = (double)baseline;
+
+    sciErr = createMatrixOfDouble(pvApiCtx,nbInputArgument(pvApiCtx)+1,1,2,tempsize);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr,0);
+        return 0;
+    }
+    sciErr = createMatrixOfDouble(pvApiCtx,nbInputArgument(pvApiCtx)+2,1,1,&returnbaseline);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr,0);
+        return 0;
+    }
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_getgaussiankernel.cpp b/sci_gateway1/cpp/opencv_getgaussiankernel.cpp
new file mode 100644
index 0000000..99c6d7d
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_getgaussiankernel.cpp
@@ -0,0 +1,142 @@
+/********************************************************
+    Author: Shubheksha Jalan
+*********************************************************
+Mat getGaussianKernel(int ksize, double sigma, int ktype=CV_64F )
+********************************************************/
+
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_getgaussiankernel(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    double ksize, sigma;
+    char **kType = NULL;
+    int i, j, k;
+
+      //checking input argument
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+
+
+    //for value of ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr, &ksize);
+    if(intErr || ksize < 0 || (int) ksize % 2 == 0)
+    {
+        return intErr;
+    }   
+
+
+    //for first value of size
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &sigma);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+      //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    kType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        kType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen, kType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    Mat temp;
+
+    if(strcmp(kType[0], "CV_32F") == 0)
+    	temp = getGaussianKernel(ksize, sigma, CV_32F
+            );
+    else if(strcmp(kType[0], "CV_64F") == 0)
+    	temp = getGaussianKernel(ksize, sigma, CV_64F);
+
+     double *m = (double *)malloc(temp.rows*temp.cols*sizeof(double));
+    for(i=0;i<temp.rows;i++)
+    {
+      for(j=0;j<temp.cols;j++)
+      {
+        uchar intensity = temp.at<uchar>(i, j);
+        *(m + i*temp.cols + j) = intensity;
+      }
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, temp.rows, temp.cols, m);
+
+	//Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
+
+
+
+
+
diff --git a/sci_gateway1/cpp/opencv_getrectsubpix.cpp b/sci_gateway1/cpp/opencv_getrectsubpix.cpp
new file mode 100644
index 0000000..2f6e835
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_getrectsubpix.cpp
@@ -0,0 +1,142 @@
+/********************************************************
+    Author: Shubheksha Jalan
+*********************************************************
+ void getRectSubPix(InputArray image, Size patchSize, Point2f center, OutputArray patch, int patchType=-1 )¶
+********************************************************/
+
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_getrectsubpix(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    int i,j,k;
+    double centerX, centerY, alpha, beta, patchType;
+ 
+
+     //checking input argument
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for first value of size
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &alpha);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+
+    //for second value of size
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr3, &beta);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+     //for x coordinate of center
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr4, &centerX);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+     //for y coordinate of center
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &centerY);
+    if(intErr)
+    {
+        return intErr;
+    }   
+     
+
+      //for patchType
+    sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &patchType);
+    if(intErr)
+    {
+        return intErr;
+    }
+
+
+    Size patchSize = Size(alpha, beta);
+
+    Point2f center = Point2f(centerX, centerY);
+
+    Mat patch;
+
+    getRectSubPix(image, patchSize, center, patch, patchType);   
+     
+
+    String tempstring = type2str(patch.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker, patch, 1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_getrotationmatrix2D.cpp b/sci_gateway1/cpp/opencv_getrotationmatrix2D.cpp
new file mode 100644
index 0000000..5a54ed2
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_getrotationmatrix2D.cpp
@@ -0,0 +1,121 @@
+/********************************************************
+    Author: Shubheksha Jalan
+*********************************************************
+Mat getRotationMatrix2D(Point2f center, double angle, double scale)
+********************************************************/
+
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_getrotationmatrix2D(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int i,j,k;
+    double centerX, centerY, angle, scale;
+
+     //checking input argument
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+
+     //for x coordinate of center
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr, &centerX);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for y coordinate of center
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr2, &centerY);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+
+    //for value of angle
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr3, &angle);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+     //for value of scale
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+     intErr = getScalarDouble(pvApiCtx, piAddr4, &scale);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+     Point2f center = Point2f(centerX, centerY);
+
+    Mat temp = getRotationMatrix2D(center, angle, scale);
+
+    double *m = (double *)malloc(temp.rows*temp.cols*sizeof(double));
+    for(i=0;i<temp.rows;i++)
+    {
+      for(j=0;j<temp.cols;j++)
+      {
+        uchar intensity = temp.at<uchar>(i, j);
+        *(m + i*temp.cols + j) = intensity;
+      }
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, temp.rows, temp.cols, m);
+
+  //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
+
diff --git a/sci_gateway1/cpp/opencv_goodfeaturestotrack.cpp b/sci_gateway1/cpp/opencv_goodfeaturestotrack.cpp
new file mode 100644
index 0000000..79e614f
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_goodfeaturestotrack.cpp
@@ -0,0 +1,168 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   corner_points = goodFeaturesToTrack( input_image, maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector((1 for true)/(0 for false)),k );
+********************************************************/
+
+
+// Abhilasha Sancheti
+// sample input :   
+//output: (image , corners)
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <math.h>
+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"
+  
+  int opencv_goodfeaturestotrack(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    
+    int i,j, detector;
+    double maxCorners  ,qualityLevel,minDistance,blocksize=3 ,k=0.04, usedetector;
+    bool useHarrisDetector = false;
+    
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 7, 7);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    Mat image;
+    retrieveImage(image,1);
+    
+    //for maximum corners
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2 ,&maxCorners);
+    if(intErr)
+        return intErr;
+     
+     
+    //for qualityLevel
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&qualityLevel);
+   if(intErr)
+        return intErr;
+
+   //for minDistance
+     sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4 ,&minDistance);
+    if(intErr)
+       return intErr;
+   
+
+   //for blocksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&blocksize);
+   if(intErr)
+     return intErr;
+
+    //for Harrisusedetector taking integer 1 or 0 
+      sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6,&usedetector);
+    if(intErr)
+        return intErr;
+     detector=(int)usedetector;
+   
+  //for k value
+  sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7 ,&k);
+   if(intErr)
+        return intErr;
+     
+
+     //checking the input parameter usedetector
+    if (detector == 1)
+      useHarrisDetector = true;
+    else if(detector == 0)
+      useHarrisDetector = false;
+    else
+    {
+      sciprint("Either 1 or 0 , 0 value was used instead");
+      useHarrisDetector = false;
+    }
+
+    /// processing of the input image and other parameters
+ if( maxCorners < 1 ) { maxCorners = 1; sciprint("maxcorners cannot be less than 1 , using 1 instead");}
+
+  /// Parameters for Shi-Tomasi algorithm
+  
+  vector<Point2f> corners;
+  /// Copy the source image
+  Mat src_gray;
+  cvtColor( image, src_gray, CV_BGR2GRAY );
+  /// Apply corner detection
+  goodFeaturesToTrack( src_gray,corners,maxCorners,qualityLevel,minDistance,Mat(),blocksize,useHarrisDetector,k );
+  
+  int row = corners.size();
+  double *cor = (double *)malloc(2*row*sizeof(double *));
+  for (int i=0;i<row;i++)
+  {
+      *(cor + i*2 + 0)=corners[i].x;
+      *(cor + i*2 + 1)=corners[i].y;
+  }
+      
+    
+  sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, row, 2, cor);
+  if(sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return 0;
+  }
+  //Assigning the list as the Output Variable
+  AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+ 
+  //Returning the Output Variables as arguments to the Scilab environment
+  ReturnArguments(pvApiCtx);
+  return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_houghcircles.cpp b/sci_gateway1/cpp/opencv_houghcircles.cpp
new file mode 100644
index 0000000..4b36aa6
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_houghcircles.cpp
@@ -0,0 +1,164 @@
+/********************************************************
+Authors: Sukul Bagai, Abhilasha Sancheti
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_houghcircles(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int i,j,k;
+    double *dp =NULL , *mindist = NULL ,*param1= NULL ,*param2=NULL;
+    double *minradius =NULL, *maxradius = NULL;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 7, 7);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+    
+   // for dp parameter of houghCircles function
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols ,&dp);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+ // for minDist parameter of houghCircles function
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols ,&mindist);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+
+     // for param1 parameter of houghCircles function 
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols ,&param1);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+      // for param2 parameter of houghCircles function 
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr5, &iRows, &iCols ,&param2);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }  
+  // for minradius parameter of houghCircles function 
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr6, &iRows, &iCols ,&minradius);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    } 
+     // for maxradius parameter of houghCircles function 
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr7, &iRows, &iCols ,&maxradius);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }  
+  
+    Mat src_gray;
+    cvtColor( src, src_gray, CV_BGR2GRAY );
+   
+    /// Reduce the noise so we avoid false circle detection
+    
+
+    vector<Vec3f> circles;
+
+    /// Apply the Hough Transform to find the circles
+    HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, dp[0], mindist[0], param1[0], param2[0], minradius[0], maxradius[0] );
+    int rows = circles.size();
+    cout<<circles.size();
+    double *output = (double *)malloc(3*rows*sizeof(double *));
+
+    /// Draw the circles detected
+    for(int i=0;i<rows;i++)
+    {
+        *(output + i*3 + 0) = circles[i][0];
+        *(output + i*3 + 1) = circles[i][1];
+        *(output + i*3 + 2) = circles[i][2];
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, rows, 3, output);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+      
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_houghlines.cpp b/sci_gateway1/cpp/opencv_houghlines.cpp
new file mode 100644
index 0000000..28202d1
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_houghlines.cpp
@@ -0,0 +1,133 @@
+/********************************************************
+Author: Shubheksha Jalan
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  int opencv_houghlines(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int i,j,k;
+    double rho, theta, srn, stn, threshold;
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+
+    Mat image;
+    retrieveImage(image, 1); 
+    cvtColor(image, image, CV_BGR2GRAY);
+    //for value of rho
+     sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   intErr = getScalarDouble(pvApiCtx, piAddr2, &rho);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value of theta
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   intErr = getScalarDouble(pvApiCtx, piAddr3, &theta);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value of threshold
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &threshold);
+     if(intErr)
+    {
+        return intErr;
+    }   
+     //for value of srn
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &srn);
+     if(intErr)
+    {
+        return intErr;
+    }   
+     //for value of stn
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &stn);
+     if(intErr)
+    {
+        return intErr;
+    }   
+    vector < vector <double> > output;
+      cout<<"here5";
+    HoughLines(image, output, rho, theta, threshold, srn, stn);
+  cout<<"here5";
+//create matrix from 2-D vector
+    int row = output.size();
+    cout<<row;
+    double *cor = (double *)malloc(row*2*sizeof(double));
+    for (int i=0;i<row;i++)
+    {
+        *(cor + i*2 +0)=output[i][0];
+ //       cout<<output[i][0]<<" "<<output[i][1];
+        *(cor + i*2 +1)=output[i][1];
+    }
+  sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, row, 2, cor);
+  if(sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return 0;
+  }
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_houghlinesp.cpp b/sci_gateway1/cpp/opencv_houghlinesp.cpp
new file mode 100644
index 0000000..1e69a09
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_houghlinesp.cpp
@@ -0,0 +1,134 @@
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  int opencv_houghlinesp(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int i,j,k;
+    double rho, theta, minLineLength = 0, maxLineGap = 0, threshold;
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+
+    Mat image;
+    retrieveImage(image, 1); 
+    cvtColor(image, image, CV_BGR2GRAY);
+    //for value of rho
+     sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   intErr = getScalarDouble(pvApiCtx, piAddr2, &rho);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value of theta
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   intErr = getScalarDouble(pvApiCtx, piAddr3, &theta);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value of threshold
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &threshold);
+     if(intErr)
+    {
+        return intErr;
+    }   
+     //for value of minLineLength
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &minLineLength);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+     //for value of maxLineGap
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &maxLineGap);
+     if(intErr)
+    {
+        return intErr;
+    }   
+
+    vector < vector <double> > output;
+
+    HoughLinesP(image, output, rho, theta, threshold, minLineLength, maxLineGap);
+
+//create matrix from 2-D vector
+    int row = output.size();
+    double *cor = (double *)malloc(row*4*sizeof(double));
+
+
+    for (int i=0;i<row;i++)
+    {
+        *(cor + i*2 +0)=output[i][0];
+ //       cout<<output[i][0]<<" "<<output[i][1];
+        *(cor + i*2 +1)=output[i][1];
+        *(cor + i*2 +2)=output[i][2];
+        *(cor + i*2 +3)=output[i][3];
+    }
+  sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, row, 4, cor);
+  if(sciErr.iErr)
+  {
+      printError(&sciErr, 0);
+      return 0;
+  }
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_im2double.cpp b/sci_gateway1/cpp/opencv_im2double.cpp
new file mode 100644
index 0000000..45ee009
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_im2double.cpp
@@ -0,0 +1,56 @@
+/********************************************************
+Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_im2double(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int i,j,k;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+    Mat image;
+    retrieveImage(image, 1); 
+
+    Mat img_dbprec;
+    image.convertTo(img_dbprec, CV_64FC3,1.0/255.0); /// Create Image with Double Precision
+
+    string tempstring = type2str(img_dbprec.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,img_dbprec,1);
+    free(checker); 
+
+    
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imageSet.cpp b/sci_gateway1/cpp/opencv_imageSet.cpp
new file mode 100644
index 0000000..9b27840
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imageSet.cpp
@@ -0,0 +1,294 @@
+
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+
+#include <iostream>
+#include <dirent.h>
+#include <vector>
+#include <string>
+#include <string.h>
+#include <algorithm>
+using namespace std;
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+
+
+    string formats[] = {"jpeg","jpg","bmp","png","JPEG","JPG","BMP","PNG"};
+
+    vector<vector<string> > descriptionVector;
+
+    const char pathSeparator =
+    #ifdef _WIN32
+                                '\\';
+    #else
+                                '/';
+    #endif
+
+    bool recursive = false;
+    bool listDirError = 0;
+
+    bool isImage(string fname)
+    {
+        for(int i=0;i<8;i++)
+        {
+            if(fname.substr(fname.length()-formats[i].length()).compare(formats[i])==0)
+                return 1;
+        }
+        return 0;
+    }
+
+    void listDir(string dirName, vector<string> &currentDir)
+    {
+        DIR *dir;
+        struct dirent *entry;
+        if(!(dir = opendir(dirName.c_str())))
+        {
+            Scierror(999,"Cannot open directory for reading. Please check the directory name.\n");
+            listDirError = 1;
+            return;
+        }
+        if(!(entry = readdir(dir)))
+        {
+            Scierror(999,"The directory is empty.\n");
+            listDirError = 1;
+            return;
+        }
+
+        do
+        {
+            if (entry -> d_type == DT_DIR)
+            {
+                if(strcmp(entry->d_name,".")==0 || strcmp(entry->d_name,"..")==0) continue;
+                if(recursive)
+                {
+                    vector<string> nextDir;
+                    nextDir.push_back(entry->d_name);
+                    listDir(dirName+pathSeparator+entry->d_name,nextDir);
+                }
+            }
+            else
+            {
+                if(isImage(entry->d_name))
+                {
+                    //cout<<dirName<<pathSeparator<<entry->d_name<<endl;
+                    currentDir.push_back(dirName+pathSeparator+entry->d_name);
+                }
+            }
+        }while(entry = readdir(dir));
+        vector<string>::iterator it = currentDir.begin();
+        sort(it+1,currentDir.end());
+        descriptionVector.push_back(currentDir);
+    }
+
+    /*Calling syntax: imageSet(imageLocation) OR imageSet(imageFolder,'recursive') */
+
+    int opencv_imageSet(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr;
+
+        //------Local variables------//
+        int *piAddr = NULL;
+        int *piChild = NULL;
+        int *piLen = NULL;
+        char **pstData = NULL;
+        int iRows, iCols;
+
+        string filePath,fileName,tempPath;
+        char **description = NULL;
+        char ***location = NULL;
+        int *count = NULL;
+        int descriptionCount = 0;
+        int pos = 0;
+        char *objectType = "imageSet";
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 1, 2);
+        CheckOutputArgument(pvApiCtx, 1, 1);
+
+        //------Get input arguments------//
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        filePath = string(pstData[0]);
+
+        if(*getNbInputArgument(pvApiCtx) == 2)
+        {
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+            }
+
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+            if(strcmp("recursive",pstData[0])!=0)
+            {
+                Scierror(999, "Error: Argument %s is invalid. \n", pstData[0]);
+                return 0;
+            }
+            recursive = true;
+        }
+
+        //------Actual processing------//
+        while(filePath[filePath.length()-1]==pathSeparator)
+        {
+            filePath = filePath.substr(0,filePath.length()-1);
+        }
+        vector<string> nextDir;
+        nextDir.push_back(filePath.substr(filePath.find_last_of(pathSeparator)+1));
+
+        listDir(filePath,nextDir);
+
+        if(listDirError)
+        {
+            listDirError = 0; //Doing this is very important as it is a global
+            return 0;
+        }
+        for(int i=0;i<descriptionVector.size();i++)
+        {
+            if(descriptionVector[i].size()>1)
+                descriptionCount++;
+
+        }
+        description = (char**) malloc(sizeof(char*) * descriptionCount);
+        count = (int*) malloc(sizeof(int) * descriptionCount);
+        location = (char***) malloc(sizeof(char**) * descriptionCount);
+
+        for(int i=0;i<descriptionVector.size();i++)
+        {
+            if(descriptionVector[i].size()>1)
+            {
+                description[pos] = (char*) malloc(sizeof(char) * descriptionVector[i][0].length() + 1);
+                descriptionVector[i][0].copy(description[pos],descriptionVector[i][0].length());
+                description[pos][descriptionVector[i][0].length()] = 0;
+
+                count[pos] = descriptionVector[i].size()-1;
+
+                location[pos] = (char**) malloc(sizeof(char*) * (descriptionVector[i].size()-1));
+                for(int j=1;j<descriptionVector[i].size();j++)
+                {
+                    location[pos][j-1] = (char*) malloc(sizeof(char) * descriptionVector[i][j].length() + 1);
+                    descriptionVector[i][j].copy(location[pos][j-1],descriptionVector[i][j].length());
+                    location[pos][j-1][descriptionVector[i][j].length()] = 0;
+                }
+                pos++;
+            }
+        }
+
+        descriptionVector.clear(); //Doing this is very important as it is a global
+        recursive = false; //Doing this is very important as it is a global
+
+        //------Create output arguments------//
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 4, &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, descriptionCount, 1, description);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 3, descriptionCount, 1, count);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 4, descriptionCount, &piChild);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        for(int i=0;i<descriptionCount;i++)
+        {
+            sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piChild, i+1, 1, count[i], location[i]);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+        }
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imcontrast.cpp b/sci_gateway1/cpp/opencv_imcontrast.cpp
new file mode 100644
index 0000000..216228f
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imcontrast.cpp
@@ -0,0 +1,100 @@
+/********************************************************
+Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+
+  int opencv_imcontrast(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int i,j,k;
+    double alpha, beta;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+
+    Mat image;
+    retrieveImage(image, 1); 
+
+    //for value of alpha
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &alpha);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value of beta
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &beta);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+
+    //we copy the original image into the new_image, and change values of each pixel using value of alpha and beta given by the user
+    Mat new_image = Mat::zeros( image.size(), image.type() );
+
+    //changes the attributes of each individual pixel
+    for( int y = 0; y < image.rows; y++ )
+    { 
+        for( int x = 0; x < image.cols; x++ )
+        { 
+            for( int c = 0; c < 3; c++ )
+            {
+                new_image.at<Vec3b>(y,x)[c] =
+                saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
+            }
+        }
+    }
+
+    
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imcrop.cpp b/sci_gateway1/cpp/opencv_imcrop.cpp
new file mode 100644
index 0000000..d180c0a
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imcrop.cpp
@@ -0,0 +1,130 @@
+/********************************************************
+Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+  int opencv_imcrop(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k;
+    double x, y, width, height;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1);
+
+    //for value of top-left x-coordinate
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &x);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value top-left y-coordinate
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &y);
+    if(intErr)
+    {
+        return intErr;
+    }
+
+    //for value of width
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &width);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    //for value of height
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &height);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    if(x>=image.cols || y>=image.rows || x<0 || y<0)
+    {
+        sciprint("Invalid x or y value\n");
+        return 0;
+    }
+    if(width<=0 || height<=0 || x+width > image.cols || y+height > image.rows)
+    {
+        sciprint("Invalid width or height value\n");
+        return 0;
+    }
+    //defining a temporary rectangle, that denotes the area that has to be cropped into the new image
+    Rect myROI(x, y, width, height);
+
+    // Crop the full image to that image contained by the rectangle myROI
+    // Note that this doesn't copy the data
+    Mat croppedRef(image, myROI);
+
+    Mat cropped;
+    // Copy the data into new matrix
+    croppedRef.copyTo(cropped);
+
+    string tempstring = type2str(cropped.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,cropped,1);
+    free(checker); 
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imfindcircles.cpp b/sci_gateway1/cpp/opencv_imfindcircles.cpp
new file mode 100644
index 0000000..2569343
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imfindcircles.cpp
@@ -0,0 +1,128 @@
+/********************************************************
+Function   :imfindcircles
+Syntax     :B=imfindcircles(A)
+Author: Tess  Zacharias
+
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+  int opencv_imfindcircles(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int *piAddrNew  = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    Mat src_gray,image;
+    double Rmin,Rmax;
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 2) ;
+    retrieveImage(image, 1);
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &Rmin);
+    if(intErr)
+    {
+        return intErr;
+    }   
+    if(Rmin!= round(Rmin) || Rmin<=0)
+    {
+        sciprint("The value of minium Radius must be an integer\n");
+        return 0;
+    }  
+    if(Rmin<5)
+    {
+        sciprint("The value of minium Radius too small\n");
+        return 0;
+    }  
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &Rmax);
+    if(intErr)
+    {
+        return intErr;
+    } 
+    if(Rmax!= round(Rmax) || Rmax<=0)
+    {
+        sciprint("The value of maximum Radius must be an integer\n");
+        return 0;
+    }  
+    cvtColor(image,src_gray, CV_BGR2GRAY);
+    GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
+    vector<Vec3f> circles;
+    HoughCircles( src_gray, circles, CV_HOUGH_GRADIENT, 2, 10, 200, 100,Rmin,Rmax);
+    int k=circles.size();
+    double *radius=NULL;
+    radius=( double *)malloc(sizeof(double)*k);
+    double *c1=NULL;
+    c1=( double *)malloc(sizeof(double)*k);
+    double *c2=NULL;
+    c2=( double *)malloc(sizeof(double)*k);
+    for( size_t i= 0; i < circles.size(); i++ )
+    {
+      c1[i]=cvRound(circles[i][0]);
+      c2[i]=cvRound(circles[i][1]);
+      radius[i]=cvRound(circles[i][2]);
+    }
+    sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 2, &piAddrNew);
+    if(sciErr.iErr)
+     {
+        printError(&sciErr, 0);
+        return 0;
+     }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddrNew, 1, 1, k, c1);
+    free(c1); 
+    if(sciErr.iErr)
+     {
+        printError(&sciErr, 0);
+        return 0;
+     } 
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddrNew, 2, 1, k, c2);
+    free(c2); 
+    if(sciErr.iErr)
+     {
+        printError(&sciErr, 0);
+        return 0;
+     } 
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1; 
+    if(Lhs==2)
+     {   
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) +2,1,k,radius);
+        free(radius);
+        if (sciErr.iErr)
+        {
+          printError(&sciErr, 0);
+          return 0;
+        }  
+       AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+     }
+    ReturnArguments(pvApiCtx);
+    return 0;         
+
+  }
+}
diff --git a/sci_gateway1/cpp/opencv_imread.cpp b/sci_gateway1/cpp/opencv_imread.cpp
new file mode 100644
index 0000000..c02af10
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imread.cpp
@@ -0,0 +1,99 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+    #include "../common.cpp"
+
+int opencv_imread(char *fname, unsigned long fname_len)
+{
+    SciErr sciErr;
+    int iLen        = 0;
+    //variable info
+    int iRows       = 0;
+    int iCols       = 0;
+    int piRows      = 0;
+    int piCols      = 0;  
+    int *piAddr = NULL;      
+    int *piLen      = NULL;
+    char **pstData  = NULL;
+    int **pstData1  = NULL;
+    int i,j,k=0;
+
+
+    //Checking number of input and output arguments (enviromnet variable, min arguments, max arguments)
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    // get Address of inputs
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    //creating image matrix, by getting the image at the specified path
+    Mat img = imread(pstData[0],CV_LOAD_IMAGE_COLOR);
+    
+    string tempstring = type2str(img.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,img,1);
+    free(checker);
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imread.cpp~ b/sci_gateway1/cpp/opencv_imread.cpp~
new file mode 100644
index 0000000..2f5ad90
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imread.cpp~
@@ -0,0 +1,99 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+    #include "../common.cpp"
+
+int opencv_imread(char *fname, unsigned long fname_len)
+{
+    SciErr sciErr;
+    int iLen        = 0;
+    //variable info
+    int iRows       = 0;
+    int iCols       = 0;
+    int piRows      = 0;
+    int piCols      = 0;  
+    int *piAddr = NULL;      
+    int *piLen      = NULL;
+    char **pstData  = NULL;
+    int **pstData1  = NULL;
+    int i,j,k=0;
+
+
+    //Checking number of input and output arguments (enviromnet variable, min arguments, max arguments)
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    // get Address of inputs
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    //creating image matrix, by getting the image at the specified path
+    Mat img = imread(pstData[0],CV_LOAD_IMAGE_UNCHANGED);
+    
+    string tempstring = type2str(img.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,img,1);
+    free(checker);
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imresize.cpp b/sci_gateway1/cpp/opencv_imresize.cpp
new file mode 100644
index 0000000..190ab5e
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imresize.cpp
@@ -0,0 +1,94 @@
+/********************************************************
+Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_imresize(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int i,j,k;
+    double alpha, beta;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1);
+
+    //for new no. of rows
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &alpha);
+    if(sciErr.iErr)
+    {
+        return intErr;
+    }   
+
+    //for new no. of columns
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &beta);
+    if(sciErr.iErr)
+    {
+        return intErr;
+    }   
+
+
+    Mat new_image;
+    Size size(alpha, beta);
+
+    if(alpha<=0 || beta<=0)
+    {
+        sciprint("Invalid new size\n");
+        return 0;
+    }
+    //resizes the image to new_image to the size given by the user
+    resize(image,new_image,size);
+
+    int temp = nbInputArgument(pvApiCtx) + 1;
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imsharpen.cpp b/sci_gateway1/cpp/opencv_imsharpen.cpp
new file mode 100644
index 0000000..ad0a593
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imsharpen.cpp
@@ -0,0 +1,59 @@
+/********************************************************
+Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_imsharpen(char *fname, unsigned long fname_len)
+  {
+
+ 	SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int i,j,k;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1); 
+    
+    Mat tmp;
+    cv::GaussianBlur(image, tmp, cv::Size(5,5), 5);
+    cv::addWeighted(image, 1.5, tmp, -0.5, 0, image);
+
+    string tempstring = type2str(image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker, image, 1);
+    free(checker); 
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_imwrite.cpp b/sci_gateway1/cpp/opencv_imwrite.cpp
new file mode 100644
index 0000000..2815ac9
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_imwrite.cpp
@@ -0,0 +1,85 @@
+/********************************************************
+Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_imwrite(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddr1 = NULL;
+    int *piLen = NULL;
+    char **pstData=NULL;
+    int i,j,k;    
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 2, 2);
+    //CheckOutputArgument(pvApiCtx, 0, 0) ;
+    Mat image;
+    retrieveImage(image, 1); 
+
+    //Now, retriving path
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //first call to retrieve dimensions
+    sciErr = getMatrixOfString(pvApiCtx, piAddr1, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr1, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    pstData = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(int i = 0 ; i < iRows * iCols ; i++)
+    {
+        pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr1, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    //image path will contain the path where the image has to be written
+    string image_path=pstData[0];
+
+    //  image_path="\""+image_path+"\"";
+
+    //writes to the path
+    imwrite(image_path,image);
+
+    return 0;
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_indexImages.cpp b/sci_gateway1/cpp/opencv_indexImages.cpp
new file mode 100644
index 0000000..6a37466
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_indexImages.cpp
@@ -0,0 +1,663 @@
+/****************************************************************************************
+* Author: Umang Agrawal                                                                 *
+* Code:   indexImages.cpp                                                               *
+* Function Call:   indexImage = indexImages( Image_Set, Bag, Optional Arguments)        *
+*          Optional Argument:   Name                  Value                             *
+*                              Verbose             Bool(1 or 0)                         *
+*                        SaveFeatureLocations      Bool(1 or 0)                         *
+****************************************************************************************/
+#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"
+#include "opencv2/ml/ml.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(const KeyPoint& p1, const KeyPoint& p2) {
+      return p1.response > p2.response;
+  }
+
+	int opencv_indexImages(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+
+    int *piAddr = NULL;
+    int *piAddr1 = NULL;
+    int *piAddr2 = NULL;
+    int *piAddr3 = NULL;
+    int *piAddr4 = NULL;
+    int *piChild = NULL;
+    int *piGrandChild = NULL;
+    int iRows, iCols;
+    int *piLen = NULL;
+    char **pstData = NULL;
+    char *objectType = "invertedImageIndex";
+    char **description = NULL;
+    char ***location = NULL;
+    int *count = NULL;
+    int descriptionCount;
+    char **arg = NULL;
+    char **filePath = NULL;
+
+    int inp_params = 0;
+    char *bagOfFeaturesLocation = NULL;
+    double *upright_bag = NULL;
+    double *strength_bag = NULL;
+    double *vocab_size_bag = NULL;
+    int count_ver = 0, count_save = 0;
+    double save = 1;
+    double verbose = 1;
+    int upright = 1;
+    int vocab_size = 500;
+    double strength = 0.8;
+
+    vector<int> key_size_vector;
+    double *wordFrequency = NULL;
+    double ***ImageWords = NULL;
+    int indx;
+
+    Mat image;
+    Mat dictionary;
+    Mat featuresUnclustered;
+    Mat feature_des;
+    Mat des_matched;
+    Mat hist;
+    vector<KeyPoint> keypoints;
+    vector<KeyPoint> valid_key;
+    vector< vector<int> > clusterID;
+    int key_size;
+    int v_key_size;
+
+    CheckInputArgument(pvApiCtx, 1, 6);						//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 1 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;
+    }
+    if( iRows!= 1 )
+    {
+      Scierror(999,"Expecting an image Set with single type of Images.\n");
+      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;
+    }
+    if( iRows!= 1 )
+    {
+      Scierror(999,"Expecting an image Set with single type of Images.\n");
+      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;
+      }
+    }
+
+//..............................................................................................................
+    inp_params = *getNbInputArgument(pvApiCtx);
+    if( inp_params>=2 )
+    {
+      sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+      if (sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+      if(!isListType(pvApiCtx, piAddr2))
+      {
+          Scierror(999, "Error: Invalid first argument. List Expected.\n");
+          return 0;
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 1, &iRows, &iCols, NULL, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+      sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 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, piAddr2, 1, &iRows, &iCols, piLen, pstData);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      if(!(strcmp(pstData[0],"bagOfFeatures")==0))
+      {
+          Scierror(999, "Error: The input argument 2 is not of type bagOfFeatures.\n");
+          return 0;
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 2, &iRows, &iCols, NULL, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+      sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 2, &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, piAddr2, 2, &iRows, &iCols, piLen, pstData);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      bagOfFeaturesLocation = pstData[0];
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr2, 3, &iRows, &iCols, &vocab_size_bag);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr2, 4, &iRows, &iCols, &strength_bag);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr2, 5, &iRows, &iCols, &upright_bag);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      upright = int(upright_bag[0]);
+      vocab_size = int(vocab_size_bag[0]);
+      strength = strength_bag[0];
+      FileStorage fs(bagOfFeaturesLocation, FileStorage::READ);
+      fs["dictionary"] >> dictionary;
+      fs.release();
+
+//................................................................................................................
+      for( int i=3; 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],"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],"SaveFeatureLocations") == 0)
+        {
+          if( count_save != 0)
+  				{
+  					Scierror(999,"SaveFeatureLoactions 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 SaveFeatureLoactions.\n");
+            return 0;
+          }
+          //Reading the Value of the argument
+          if(getScalarDouble(pvApiCtx, piAddr4, &save))
+          {
+            Scierror(999,"Not a valid type of value for SaveFeatureLoactions.\n");
+            return 0;
+          }
+          if( !(save == 1|| save == 0) )
+          {
+            Scierror(999,"Enter a valid value for SaveFeatureLoactions (Either 0 or 1)\n");
+            return 0;
+          }
+  				i++;
+          count_save += 1;
+        }
+        else
+        {
+          Scierror(999,"Invalid Argument Name\n");
+          return 0;
+        }
+      }
+    }
+
+    if(int(verbose))
+    {
+      sciprint("Creating an Inverted image Index Using Bag-Of-Features.\n");
+      sciprint("--------------------------------------------------------\n");
+    }
+
+    if( inp_params == 1)
+    {
+      bagOfFeaturesLocation = "Bag-Of-Features.yml";
+      SurfFeatureDetector detector(100, 4, 2, 1, upright);
+  		SurfDescriptorExtractor extractor(100, 4, 2, 1, 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++)
+  			{
+  				if(int(verbose))
+  					sciprint(".");
+  				keypoints.clear();
+          valid_key.clear();
+  				image = imread(location[i][j],1);
+  				detector.detect(image, keypoints);
+          sort(keypoints.begin(), keypoints.end(), response);
+  				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);
+  			}
+  		}
+
+  		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(bagOfFeaturesLocation, FileStorage::WRITE);
+  	  fs<<"dictionary"<<dictionary;
+  	  fs.release();
+    }
+
+    filePath = (char**)malloc(sizeof(char*)*1*1);
+    filePath[0] = (char*)malloc(sizeof(char)*20*1);
+    strcpy(filePath[0],bagOfFeaturesLocation);
+
+    if(int(verbose))
+    {
+      sciprint("Encoding 1 Image Set using Bag-Of-Features.\n");
+      sciprint("--------------------------------------------\n");
+    }
+
+    if(int(verbose))
+    {
+      sciprint("\nImage set 1: %s\n\n",description[0]);
+      sciprint("Encoding %d images from image set 1",count[0]);
+    }
+
+    ImageWords = (double***)malloc(sizeof(double**)*count[0]*1);
+    wordFrequency = (double*)malloc(sizeof(double)*vocab_size);
+    for( int j=0; j<vocab_size; j++)
+    {
+      wordFrequency[j] = 0;
+    }
+
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
+    Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(100, 4, 2, 1, 1);
+    SurfFeatureDetector detector(100, 4, 2, 1, 1);
+    BOWImgDescriptorExtractor bowDE(extractor, matcher);
+    bowDE.setVocabulary(dictionary);
+    for( int i=0; i<count[0]; i++)
+    {
+      if(int(verbose))
+        sciprint(".");
+      valid_key.clear();
+      keypoints.clear();
+      feature_des.release();
+      image = imread(location[0][i],1);
+      detector.detect(image, keypoints);
+      bowDE.compute(image, keypoints, hist, &clusterID, &des_matched);
+
+      key_size_vector.push_back(keypoints.size());
+      ImageWords[i] = (double**)malloc(sizeof(double*)*4*1);
+      ImageWords[i][0] = (double*)malloc(sizeof(double)*keypoints.size()*1);
+      ImageWords[i][1] = (double*)malloc(sizeof(double)*keypoints.size()*2);
+      ImageWords[i][2] = (double*)malloc(sizeof(double)*1);
+      ImageWords[i][3] = (double*)malloc(sizeof(double)*1);
+
+      ImageWords[i][2][0] = vocab_size;
+      ImageWords[i][3][0] = keypoints.size();
+
+      for( int j=0; j<keypoints.size(); j++)
+      {
+        ImageWords[i][1][j] = keypoints[j].pt.x;
+        ImageWords[i][1][keypoints.size() + j] = keypoints[j].pt.y;
+      }
+      for( int j=0; j<clusterID.size(); j++)
+      {
+        wordFrequency[j] = wordFrequency[j]+clusterID[j].size();
+        for( int k=0; k<clusterID[j].size(); k++)
+        {
+            indx = clusterID[j][k];
+            ImageWords[i][0][indx] = j;
+        }
+      }
+    }
+    if(int(verbose))
+    {
+      sciprint("done.\n\n");
+      sciprint("Finished encoding images.\nFinished creating the image index\n");
+    }
+
+    sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 4+int(save), &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 = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 2, count[0], &piChild);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    for( int i=0; i<count[0]; i++)
+    {
+      sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piChild, i+1, 4, &piGrandChild);
+      if(sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+      sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piGrandChild, 1, key_size_vector[i], 1, ImageWords[i][0]);
+      if(sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+      sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piGrandChild, 2, key_size_vector[i], 2, ImageWords[i][1]);
+      if(sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+      sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piGrandChild, 3, 1, 1, ImageWords[i][2]);
+      if(sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+      sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piGrandChild, 4, 1, 1, ImageWords[i][3]);
+      if(sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+    }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 3, vocab_size, 1, wordFrequency);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 4, 1, 1, filePath);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    if(int(save) == 1)
+    {
+      sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 5, descriptionCount, &piChild);
+      if(sciErr.iErr)
+      {
+          printError(&sciErr, 0);
+          return 0;
+      }
+      for(int i=0;i<descriptionCount;i++)
+      {
+          sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piChild, i+1, 1, count[i], location[i]);
+          if(sciErr.iErr)
+          {
+              printError(&sciErr, 0);
+              return 0;
+          }
+      }
+    }
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+    ReturnArguments(pvApiCtx);
+    return 0;
+  }
+}
diff --git a/sci_gateway1/cpp/opencv_integralFilter.cpp b/sci_gateway1/cpp/opencv_integralFilter.cpp
new file mode 100644
index 0000000..093f4e3
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_integralFilter.cpp
@@ -0,0 +1,250 @@
+/***************************************************
+Author : Tanmay Chaudhari
+ ***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+	//    #include "../common.cpp"
+
+	int opencv_integralFilter(char *fname, unsigned long fname_len)
+	{
+		//Error management variable
+		SciErr sciErr;
+		
+		//Variable declaration
+		int i, j, k;
+		int iType = 0;
+		int iComplex = 0;
+		int rowsOfintImage = 0;
+		int colsOfintImage = 0;
+		int rowsOfBbox = 0;
+		int rowsOfWeights = 0;
+		int colsOfBbox = 0;
+		int colsOfWeights = 0;
+		int rowsOfFilter = 0;
+		int colsOfFilter = 0;
+		int sR = 0;
+		int sC = 0;
+		int eR = 0;
+		int eC = 0;
+		int *piAddr = NULL;
+		int *outSize = NULL;
+		double bboxSum = 0;
+		double *integralFilter = NULL;
+		double *intImage = NULL;
+		double *bbox = NULL;
+		double *weights = NULL;		
+		double *filterSize = NULL;
+
+		//Check input output argument
+		checkInputArgument(pvApiCtx, 4, 4);
+		checkOutputArgument(pvApiCtx, 1, 1);
+	
+		//Get variable address of the first input arguent
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfintImage, &colsOfintImage, &intImage);
+		if(sciErr.iErr || rowsOfintImage == 0 || colsOfintImage == 0)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get variable address of the second input arguent
+		sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfBbox, &colsOfBbox, &bbox);
+		if(sciErr.iErr || colsOfBbox != 4 || rowsOfBbox == 0)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get variable address of the third input arguent
+		sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfWeights, &colsOfWeights, &weights);
+		if(sciErr.iErr || colsOfWeights == 0 || rowsOfWeights != 1 || colsOfWeights != rowsOfBbox)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get variable address of the fourth input arguent
+		sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfFilter, &colsOfFilter, &filterSize);
+		if(sciErr.iErr || colsOfFilter != 2 || rowsOfFilter != 1)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+	
+		outSize = (int*)malloc(sizeof(int) * 2);
+		if(filterSize[0] != 0 && filterSize[1] != 0)
+		{
+			outSize[0] = rowsOfintImage - filterSize[0];	
+			outSize[1] = colsOfintImage - filterSize[1];
+		}
+		else
+		{
+			outSize[0] = rowsOfintImage - 1;
+			outSize[1] = colsOfintImage - 1;
+		}
+		
+		if(outSize[0] <= 0 || outSize[1] <= 0)
+			outSize[0] = outSize[1] = 0;
+			
+		integralFilter = (double*)malloc(sizeof(double) * outSize[0] * outSize[1]);
+		
+		for( i = 0; i < outSize[0] * outSize[1]; i++)
+			integralFilter[i] = 0;
+			
+		for( i = 1; i <= outSize[1]; i++)
+		{
+			for( j = 1; j <= outSize[0]; j++)
+			{
+				for( k = 0; k < rowsOfBbox; k++)
+				{
+					sR = j + bbox[1 * rowsOfBbox + k] - 1;
+					sC = i + bbox[0 * rowsOfBbox + k] - 1;
+					eR = sR + bbox[3 * rowsOfBbox + k];
+					eC = sC + bbox[2 * rowsOfBbox + k];
+					
+					bboxSum = intImage[(eC - 1) * rowsOfintImage + (eR - 1)] - intImage[(sC - 1) * rowsOfintImage + (eR - 1)];
+					bboxSum -= intImage[(eC - 1) * rowsOfintImage + (sR - 1)];
+					bboxSum += intImage[(sC - 1) * rowsOfintImage + (sR - 1)];
+
+					integralFilter[(j - 1) * outSize[1] + (i - 1)] = integralFilter[(j - 1) * outSize[1] + (i - 1)] + weights[k] * bboxSum; 
+				}
+			}
+		}
+
+		//Creating list to store integral filter in it
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, outSize[0], outSize[1], integralFilter);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Return output arguments
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+
+		return 0;
+	}
+	/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_integralImage.cpp b/sci_gateway1/cpp/opencv_integralImage.cpp
new file mode 100644
index 0000000..b40e268
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_integralImage.cpp
@@ -0,0 +1,153 @@
+/***************************************************
+Author : Tanmay Chaudhari
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <bits/stdc++.h>
+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"
+ //   #include "../common.cpp"
+
+int opencv_integralImage(char *fname, unsigned long fname_len)
+{
+	//Error management variable
+	SciErr sciErr;
+	
+	//Variable declaration
+	int nbInputArguments = 0;
+	int iRows = 0;
+	int iCols = 0;
+	int *piLen = NULL;
+	int *piAddr = NULL;
+	int tilted = 0;
+	char **pstData  = NULL;
+	double *integralImage;
+	Mat image, sum, sqsum, tiltedsum;
+
+	//Check input output arguments
+	checkInputArgument(pvApiCtx, 1, 2);
+	checkOutputArgument(pvApiCtx, 1, 1);
+
+	nbInputArguments = *getNbInputArgument(pvApiCtx);
+	
+	//getting input arguments
+	retrieveImage(image, 1); 
+
+	if(nbInputArguments == 2)
+	{
+		sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		// Extracting name of next argument takes three calls to getMatrixOfString
+		sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+
+		sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+		for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+		{
+			pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+		}
+
+		sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+		if (sciErr.iErr)
+		{
+			printError(&sciErr, 0); 
+			return 0; 
+		}
+
+		if(strcmp(pstData[0],"upright")==0)
+			tilted=0;
+		else if(strcmp(pstData[0],"rotated")==0)
+			tilted=1;
+		else
+		{
+			Scierror(999, "Error: Please provide proper value for \"%s\". Permissible values are upright or rotated.\n", pstData[0]); 
+			return 0; 
+		}
+	}
+
+	integral(image,sum,sqsum,tiltedsum);
+
+	if(tilted==0)
+	{
+		integralImage = (double*)malloc(sizeof(double) * int(sum.rows) * int(sum.cols));
+		for(int i=0;i<sum.rows;i++)
+		{
+			for(int j=0;j<sum.cols;j++)
+			{
+				integralImage[j*int(sum.rows)+i] = sum.at<int>(i,j);
+			}
+		}
+	}
+	else
+	{
+		integralImage = (double*)malloc(sizeof(double) * int(sum.rows) * (int(sum.cols)+1));
+		for(int i=0;i<sum.rows;i++)
+		{
+			for(int j=0;j<=sum.cols;j++)
+			{
+				integralImage[j*sum.rows+i]=0;
+			}
+		}
+		for(int i=0;i<sum.rows;i++)
+		{
+			for(int j=0;j<sum.cols;j++)
+			{
+					integralImage[j*int(sum.rows)+i] = tiltedsum.at<int>(i,j);
+			}
+		}
+	}
+
+	sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+
+	if(tilted==0)
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, int(sum.rows), int(sum.cols), integralImage);
+	else
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, int(sum.rows), int(sum.cols)+1, integralImage);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+
+	//Return output arguments
+	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+	ReturnArguments(pvApiCtx);
+	
+	return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_integralKernel.cpp b/sci_gateway1/cpp/opencv_integralKernel.cpp
new file mode 100644
index 0000000..5dfabf3
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_integralKernel.cpp
@@ -0,0 +1,251 @@
+/***************************************************
+Author : Tanmay Chaudhari
+ ***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+	//    #include "../common.cpp"
+
+	int opencv_integralKernel(char *fname, unsigned long fname_len)
+	{
+		//Error management variable 
+		SciErr sciErr;
+
+		//Variable declaration
+		int i, j, k;
+		int iType = 0;
+		int iComplex = 0;
+		int rowsOfBbox = 0;
+		int rowsOfWeights = 0;
+		int colsOfBbox = 0;
+		int colsOfWeights = 0;
+		int *piAddr = NULL;
+		double *filterSize = NULL;
+		double *hlSize = NULL;
+		double *ulCorner = NULL;
+		double *lrCorner = NULL;
+		double *centre = NULL;
+		double sR = 0;
+		double sC = 0;
+		double eR = 0;
+		double eC = 0;
+		double *coefficients = NULL;
+		double *bbox = NULL;
+		double *weights = NULL;
+
+		//Check input output argument
+		checkInputArgument(pvApiCtx, 2, 2);
+		checkOutputArgument(pvApiCtx, 5, 5);
+
+		//Get variable address of the first input arguent
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfBbox, &colsOfBbox, &bbox);
+		if(sciErr.iErr || colsOfBbox != 4 || rowsOfBbox == 0)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get variable address of the second input arguent
+		sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rowsOfWeights, &colsOfWeights, &weights);
+		if(sciErr.iErr || colsOfWeights == 0 || rowsOfWeights != 1 || colsOfWeights != rowsOfBbox)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Creating list to storing bouding boxes
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, rowsOfBbox, colsOfBbox, bbox);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Creating list to store weights
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 2, piAddr, 1, rowsOfWeights, colsOfWeights, weights);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Computing filter size
+		filterSize = (double*)malloc(sizeof(double) * 2);
+		hlSize = (double*)malloc(sizeof(double) * 2);
+		ulCorner = (double*)malloc(sizeof(double) * 2);
+		lrCorner = (double*)malloc(sizeof(double) * 2);
+
+		filterSize[0] = filterSize[1] = 0;
+		for( i = 0 ; i < rowsOfBbox; i++)
+		{
+			hlSize[0] = bbox[3 * rowsOfBbox + i];
+			hlSize[1] = bbox[2 * rowsOfBbox + i];
+
+			ulCorner[0] = bbox[1 * rowsOfBbox + i];
+			ulCorner[1] = bbox[0 * rowsOfBbox + i];
+
+			lrCorner[0] = ulCorner[0] + hlSize[0] - 1;	
+			lrCorner[1] = ulCorner[1] + hlSize[1] - 1;
+
+			if(filterSize[0] < lrCorner[0])
+				filterSize[0] = lrCorner[0];
+			if(filterSize[1] < lrCorner[1])
+				filterSize[1] = lrCorner[1];
+		}
+	
+		//Computing coefficient matrix
+		coefficients = (double*)malloc(sizeof(double) * int(filterSize[0]) * int(filterSize[1]));
+		for( i = 0; i < int(filterSize[0]) * int(filterSize[1]); i++)
+			coefficients[i] = 0;
+
+		for( i = 0; i < rowsOfBbox; i++)
+		{
+			sR = bbox[1 * rowsOfBbox + i];
+			sC = bbox[0 * rowsOfBbox + i];
+			eR = sR + bbox[3 * rowsOfBbox + i] - 1;
+			eC = sC + bbox[2 * rowsOfBbox + i] - 1;
+
+			for( j = sR - 1; j < eR; j++)
+				for( k = sC - 1; k < eC; k++)
+					coefficients[k * int(filterSize[0]) + j] += weights[i];
+		}
+
+		//Computing centre of filter
+		centre = (double*)malloc(sizeof(double) * 2);
+		centre[0] = ceil(filterSize[0]/2.0);
+		centre[1] = ceil(filterSize[1]/2.0);
+	
+		//Storing coefficient matrix in list
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, piAddr, 1, int(filterSize[0]), int(filterSize[1]), coefficients);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		
+		//Storing centre of filter in list
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 4, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 4, piAddr, 1, 1, 2, centre);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		
+		//Storing size of filter in list
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 5, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 5, piAddr, 1, 1, 2, filterSize);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Return output arguments
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+		AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+		AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+		AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+		ReturnArguments(pvApiCtx);
+
+		return 0;
+	}
+	/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_isEpipoleInImage.cpp b/sci_gateway1/cpp/opencv_isEpipoleInImage.cpp
new file mode 100644
index 0000000..8663032
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_isEpipoleInImage.cpp
@@ -0,0 +1,164 @@
+/********************************************************
+Author: Suraj Prakash
+[isepi, epipole] = isEpipoleInImage(fundamental_matrix, imagesize)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+
+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"
+  
+  int opencv_isEpipoleInImage(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j, n = 0;
+
+    int iRows = 0;
+    int iCols = 0;
+    
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddr2 = NULL;
+    
+    double *pdblReal = NULL;
+    double *imagesize = NULL;
+    
+    int isepi = 0;
+    double *epipole = NULL;
+    double inf = 1e17;
+    /// take the fundamental matrix 
+    Mat fundamental_matrix(3, 3, CV_64F);
+
+    epipole = (double*)malloc(sizeof(double*) * 2);
+    memset(epipole, 0, 2);
+   
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+    if (sciErr.iErr){
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(iRows != 3 and iCols != 3){
+        Scierror(999, "Incorrect dimension of martrix for argument\n"); 
+        return 0; 
+    }
+
+    for(i = 0; i < 3; ++i)
+        for(j = 0; j < 3; ++j)
+            fundamental_matrix.at<double>(i, j) = pdblReal[i + j * 3];
+
+
+    /// Get image size    
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr){
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(iRows != 1 and iCols != 2){
+        Scierror(999, "Invalid array for imagesize provided\n"); 
+        return 0; 
+    }
+
+    imagesize = (double*)malloc(sizeof(double) * 2);
+    imagesize[0] = pdblReal[0];
+    imagesize[1] = pdblReal[1];
+
+    /// compute the SVD of the matrix provided
+    Mat w, u, vt;
+    SVD::compute(fundamental_matrix, w, u, vt);
+
+    transpose(vt, vt);
+
+    /// getting the last column of the vt
+    Mat epipoleHmg(1, 3, CV_64F);
+
+    epipoleHmg.at<double>(0,0) = vt.at<double>(0, 2);
+    epipoleHmg.at<double>(0,1) = vt.at<double>(1, 2);
+    epipoleHmg.at<double>(0,2) = vt.at<double>(2, 2);
+
+
+    if(epipoleHmg.at<double>(0,2) != 0){
+        /// location of epipolecl
+
+        epipole[0] = epipoleHmg.at<double>(0, 0) / epipoleHmg.at<double>(0, 2);
+        epipole[1] = epipoleHmg.at<double>(0, 1) / epipoleHmg.at<double>(0, 2);
+
+        double *imageOrigin = NULL;
+        imageOrigin = (double*)malloc(sizeof(double) * 2);
+        memset(imageOrigin, 0.5, 2);
+
+        double *imageEnd = NULL;
+        imageEnd = (double*)malloc(sizeof(double) * 2);
+        memset(imageEnd, 0, 2);
+
+        /// imageend = imageorigin + imagesize(::-1)
+        imageEnd[0] = imageOrigin[0] + imagesize[1];
+        imageEnd[1] = imageOrigin[1] + imagesize[0];
+
+        if(epipole[0] >= imageOrigin[0] and epipole[1] >= imageOrigin[1] and epipole[0] <= imageEnd[0] and epipole[1] <= imageEnd[1])
+            isepi = 1;
+        else
+            isepi = 0;
+    }
+
+    else{
+        epipole[0] = epipoleHmg.at<double>(0, 0) > 0 ? inf : -inf;
+        epipole[1] = epipoleHmg.at<double>(0, 1) > 0 ? inf : -inf;
+    }
+
+    
+     
+
+
+    int iRet = createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, isepi);
+    if(iRet){
+        printError(&sciErr, 0); 
+        return 0; 
+    }
+    
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, 1, 2, epipole); 
+    if(sciErr.iErr){
+        printError(&sciErr, 0); 
+        return 0; 
+    }
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2; 
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+    }
+    
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_isfilter.cpp b/sci_gateway1/cpp/opencv_isfilter.cpp
new file mode 100644
index 0000000..963ae0a
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_isfilter.cpp
@@ -0,0 +1,237 @@
+/*********************************************************************************
+*Author : Kevin George
+*
+*-> To execute, isfilter("Data",..,"Size",..)
+*   
+*
+*********************************************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include <iostream>
+#include <math.h>
+#include <vector>
+
+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"
+    // # include "../common.cpp"
+
+    int opencv_isfilter(char *fname, unsigned long fname_len)
+    {
+    	//-> Error Management variables
+    	SciErr sciErr;
+    	int intErr=0;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+
+        //-> Local variables
+        double size;
+        double *data = NULL;
+
+        Mat s;
+  		Mat u;
+  		Mat v;
+
+  		int num_InputArgs;  //-> gives total number of arguments
+  		int iRows, iCols;
+        int *piLen = NULL;
+        char **pstData = NULL;  //-> why double pointer?? and what is it 
+  		char *currentArg = NULL; //-> Stores current string representing 'name' of name,value pair arguments
+        bool *providedArgs = NULL; //-> Used to check that optional argument is not entered more than once 
+
+  		//-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        //-> Checks number of input and output arguments
+        CheckInputArgument(pvApiCtx, 4 , 4);                     
+        CheckOutputArgument(pvApiCtx, 1, 1);
+
+        //-> Count number of input arguments
+        num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        providedArgs = (bool*) malloc(sizeof(bool) * 2);
+
+//*****************************************************  Getting Input Arguments  *************************************************************
+        for(int iter = 1; iter<= num_InputArgs; iter++)
+        {
+        	//-> Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            //-> Extracting name of next argument takes three calls to getMatrixOfString
+            //-> First call to get rows and columns
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+            //-> Second call to retrieve length of each string
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+
+            //-> Third call to retrieve data
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            currentArg = pstData[0];
+            free(pstData);
+            iRows=0;
+            iCols=0;
+            free(piLen);
+
+        
+
+//****************************************************** Name,Value - Data *****************************************************************
+
+            if(strcmp(currentArg, "Data")==0)
+            {
+            	if(iter+1<= num_InputArgs && !providedArgs[0])
+                {
+                	 sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &data); 
+                    if(sciErr.iErr)
+                    {
+                      printError(&sciErr, 0);
+                      return 0;
+                    }
+
+                    /*if(iRows*iCols!=)
+                    {   
+                      Scierror(999,"Invalid Argument\n");
+                      return 0;
+                    } */
+
+                    providedArgs[0] = 1;
+                }
+
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0;
+                }
+
+            }
+
+//****************************************************** Name,Value - Size *****************************************************************
+            else if(strcmp(currentArg, "Size")==0)
+            {
+            	if(iter+1<= num_InputArgs && !providedArgs[1])
+                {
+                	 sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &size); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                    if( size < 0)
+                    {
+                        Scierror(999," Invalid Value for NumPyramidLevels. Please enter a non negative Double value\\n");
+                        return 0;
+                    }
+                    providedArgs[1] = 1;
+                }
+
+                else if(providedArgs[1]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0;
+                }
+
+            }
+
+        }
+//*****************************************************  Actual Processing  *************************************************************
+ 
+        int size2 = int(size);
+        float *kdata = new float[size2*size2];
+
+        for(int i = 0;i<size2*size2; i++)
+        {
+        	kdata[i] = float(data[i]);
+        }
+
+ 		Mat kernel( size2, size2, CV_32F, kdata);
+ 		SVD::compute(kernel,s,u,v);
+
+ 		int count = 0;
+	    for(int i = 0; i < s.rows; i++)
+	    {
+	      for(int j = 0; j < s.cols; j++)
+	        {
+	          if( s.at<float>(i,j) != 0)
+	            count++;
+	        }
+	    }
+
+	    if (count == 1)
+	    	 sciprint("\nFilter is seperale\n");
+
+	    else
+	    	sciprint("\nFilter is not seperale\n");
+
+	    ReturnArguments(pvApiCtx);
+    	return 0;
+    }
+
+ }
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_laplacian.cpp b/sci_gateway1/cpp/opencv_laplacian.cpp
new file mode 100644
index 0000000..46ce129
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_laplacian.cpp
@@ -0,0 +1,156 @@
+/********************************************************
+    Author: Sukul Bagai
+*********************************************************
+   return_image = laplacian(input_image , depth , ksize , scale, delta);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_laplacian(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    char **ddepth = NULL;
+    int i,j,k;
+    double ksize,scale,delta;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    ddepth = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        ddepth[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, ddepth);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for value of ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&ksize);
+    if(intErr)
+        return intErr;
+    
+    //for value of scale
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&scale);
+    if(intErr)
+        return intErr;
+
+    //for value of delta
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&delta);
+    if(intErr)
+        return intErr;
+
+
+    Mat new_image(image.rows,image.cols,CV_8UC3);
+    if((int)ksize!=1 && (int)ksize!=3 && (int)ksize!=5 && (int)ksize!=7)
+    {
+        sciprint("Value of 1,3,5,7 Required for ksize. Default value of 3 was used instead");
+        ksize=3;
+    }
+
+    if(strcmp(ddepth[0],"CV_8U")==0)
+        Laplacian(image,new_image,CV_8U,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_16U")==0)
+        Laplacian(image,new_image,CV_16U,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_16S")==0)
+        Laplacian(image,new_image,CV_16S,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_32F")==0)
+        Laplacian(image,new_image,CV_32F,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_64F")==0)
+        Laplacian(image,new_image,CV_64F,ksize,scale,delta);
+    else 
+    {
+       Laplacian(image,new_image,CV_8U,ksize,scale,delta);
+       sciprint("Wrong depth given,using CV_8U instead");   
+    }
+    
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_line.cpp b/sci_gateway1/cpp/opencv_line.cpp
new file mode 100644
index 0000000..c047381
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_line.cpp
@@ -0,0 +1,211 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   return_image = line(image , x1 , y1 , x2,y2,r_value,g_value,b_value,thickness,linetype,shift);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_line(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10  = NULL;
+    int *piAddr11=NULL;
+    int i,j,k;
+    double thickness=1,linetype=8,shift=0 ,x1,y1,x2,y2,r_value,g_value,b_value;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 8, 11);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+    
+    //for value of x coordinate of first point
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2 ,&x1);
+    if(intErr)
+      return intErr;
+    
+    //for value of y coordinate of first point
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&y1);
+     if(intErr)
+      return intErr;
+
+    //for value of x coordinate of second point
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4 ,&x2);
+     if(intErr)
+      return intErr;
+
+    ///for value of y coordinate of second point
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5 ,&y2);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+      //for value of R value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr) 
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6 ,&r_value);
+    if(intErr)
+      return intErr;
+
+    // for G value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7 ,&g_value);
+     if(intErr)
+      return intErr;
+
+    // for B value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8,&b_value);
+    if(intErr)
+      return intErr;
+
+    // for thickness of line default: 1
+    sciErr = getVarAddressFromPosition(pvApiCtx,9,&piAddr9);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr9,&thickness);
+    if(intErr)
+      return intErr;
+  
+      //for line type of line default: 8 
+    sciErr = getVarAddressFromPosition(pvApiCtx,10,&piAddr10);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+  
+    intErr = getScalarDouble(pvApiCtx, piAddr10 ,&linetype);
+    if(intErr)
+      return intErr;
+
+    // for shift in line defulat : 0
+     sciErr = getVarAddressFromPosition(pvApiCtx,11,&piAddr11);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Syntax: sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
+    intErr = getScalarDouble(pvApiCtx, piAddr11 ,&shift);
+    if(intErr)
+      return intErr;
+   
+   
+    //temporary pt variable, to use in function as centre
+    Point pt1(x1,y1);
+     Point pt2(x2,y2);
+  /// checking the parmeters for correct values   
+    if( r_value <0 || r_value >255)
+     {
+          r_value=0;
+          sciprint(" r value of colour should be between 0 and 255 , using 0 instead");
+     }
+     if( g_value <0 || g_value >255)
+     {
+          g_value=0;
+          sciprint("  g value of colour should be between 0 and 255 , using 0 instead");
+     }
+    if( b_value <0 || b_value >255)
+     {
+          b_value=0;
+          sciprint(" b value of colour should be between 0 and 255 , using 0 instead");
+     }
+    if ((linetype!=0) && (linetype!=4)&& (linetype!=8))
+    {
+             linetype=8;
+             sciprint("Only 0/4/8 allowed , using 8 instead");
+     }
+
+//calling the opencv function
+    line( src, pt1, pt2, Scalar(b_value,g_value,r_value), thickness, linetype, shift);
+     
+    int temp = nbInputArgument(pvApiCtx) + 1;
+    string tempstring = type2str(src.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,src,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_matchFeatures.cpp b/sci_gateway1/cpp/opencv_matchFeatures.cpp
new file mode 100644
index 0000000..c8a35fd
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_matchFeatures.cpp
@@ -0,0 +1,490 @@
+/********************************************************************************************************************************************************************************************************
+*	Author:	Umang Agrawal																						*
+* 	Code:	matchFeatures.cpp																					*
+*	Function Format:	[ index_Pairs_of_Matched_fetaures Metric ] = matchFeatures( feature_Vector_1, feature_Vector_2, Optional Arguments )							*
+*			Optional Arguments:		Name			Value															*
+*							'Method'		[ 'Exhaustive' : 'Brute Force Matching', 'Approximate' : FANN Based Matching' ]						*
+*							'Metric'		[ 'SSD', 'SAD', 'Hamming', 'Hamming_2' ]										*
+*							'Unique'		[ Boolean True or False ]												*
+*							'MatchThreshold'	[ Percentage: 0 - 100 ]													*
+********************************************************************************************************************************************************************************************************/
+#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"
+
+	int opencv_matchFeatures(char *fname, unsigned long fname_len)
+	{
+		// Error Handling		
+		SciErr sciErr;
+
+		// Address of Various Scilab API
+		int *piAddr1 = NULL;
+		int *piAddr2 = NULL;
+		int *piAddr3 = NULL;
+		int *piAddr4 = NULL;
+
+		// Number of input and output Arguments
+		int inputArguments = 0;
+
+		int Rows_1,Cols_1;
+		int Rows_2,Cols_2;
+
+		double *feature_1 = NULL;
+		double *feature_2 = NULL;
+
+		int iRows, iCols;	
+		int *pilen = NULL;
+		char **arg = NULL;
+		char **method = NULL;
+		char **metric = NULL;
+		double unique = 0;
+		double thresh = 10;
+
+		int count_method = 0,count_metric = 0, count_unique = 0, count_thresh = 0;		
+
+		double max_dist = 0, min_dist;
+		double *indexPairs = NULL;
+		double *matchMetric = NULL;
+
+		vector <DMatch> matches;
+		vector <DMatch> valid_m;		
+
+		// Checks on Number of Input and Output Arguments
+		CheckInputArgument(pvApiCtx, 2, 10);
+		CheckOutputArgument(pvApiCtx, 1, 2);
+
+		inputArguments = *getNbInputArgument(pvApiCtx);
+
+		if( inputArguments%2 == 0 )
+		{
+			//Feature Matrix 1			
+			sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			if( !isVarMatrixType(pvApiCtx, piAddr1))
+			{
+				Scierror(999,"Expecting a Matrix of MxN order containing the Binary Feature Set of Image 1 (Query Image)\n");
+				return 0;
+			}
+			if( !isDoubleType(pvApiCtx, piAddr1))
+			{
+				Scierror(999,"Feature Matrix should be of Double Type\n");
+				return 0;
+			}
+			sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &Rows_1, &Cols_1, &feature_1);
+			if(sciErr.iErr)			
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+ 
+			//Feature Matrix 2
+			sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+			if(sciErr.iErr)
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+			if( !isVarMatrixType(pvApiCtx, piAddr2))
+			{
+				Scierror(999,"Expecting a Matrix of MxN order containing the Binary Feature Set of Image 1 (Query Image)\n");
+				return 0;
+			}
+			if( !isDoubleType(pvApiCtx, piAddr2))
+			{
+				Scierror(999,"Feature Matrix should be of Double Type\n");
+				return 0;
+			}
+			sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &Rows_2, &Cols_2, &feature_2);
+			if(sciErr.iErr)			
+			{
+				printError(&sciErr, 0);
+				return 0;
+			}
+		}
+		else
+		{
+			Scierror(999,"Required Arguments are Missing\n");
+			return 0;
+		}
+
+		for( int i=3; i<=inputArguments; i++)
+		{
+			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 #%d. A string is expected.\n", fname, 1);
+				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],"Method") == 0)
+			{
+				if(count_method != 0)
+				{
+					Scierror(999,"Method argument 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;
+				}
+				//Check for Argument type
+				if( !isStringType(pvApiCtx, piAddr4))
+				{
+					Scierror(999, "%s: Wrong type of value for Method Argument. A string is expected.\n");
+					return 0;
+				}
+				//Matrix of Stings
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &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, piAddr4, &iRows, &iCols, pilen, NULL);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					return 0;
+				}
+				method = (char**)malloc(sizeof(char*) * iRows * iCols);
+				for(int j=0;j< iRows * iCols; j++)
+				{
+					method[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+				}
+				//third call to retrieve data
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, pilen, method);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					free(method);
+					return 0;
+				}
+				i++;
+				count_method += 1;
+			}
+			else if(strcmp(arg[0],"Metric") == 0)
+			{
+				if(count_metric != 0)
+				{
+					Scierror(999,"Metric argument 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;
+				}
+				//Check for Argument type
+				if( !isStringType(pvApiCtx, piAddr4))
+				{
+					Scierror(999, "%s: Wrong type of Value for Metric Argument. A string is expected.\n");
+					return 0;
+				}
+				//Matrix of Stings
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &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, piAddr4, &iRows, &iCols, pilen, NULL);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					return 0;
+				}
+				metric = (char**)malloc(sizeof(char*) * iRows * iCols);
+				for(int j=0;j< iRows * iCols; j++)
+				{
+					metric[j] = (char*)malloc(sizeof(char) * (pilen[j] + 1));
+				}
+				//third call to retrieve data
+				sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, pilen, metric);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					free(pilen);
+					free(metric);
+					return 0;
+				}
+				i++;
+				count_metric += 1;	
+			}
+			else if(strcmp(arg[0],"Unique") == 0)
+			{
+				if(count_unique != 0)
+				{
+					Scierror(999,"Unique argument 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;
+				}
+				//Check for Argument type
+				if( !(isDoubleType(pvApiCtx, piAddr4)) )
+				{
+					Scierror(999,"Unique Value must be a logic scalar\n");
+					return 0;
+				}
+				if(getScalarDouble(pvApiCtx, piAddr4, &unique))
+				{
+					Scierror(999,"Cannot Read Upright Value\n");
+					return 0;
+				}
+				if( !(int(unique)==0 || int(unique)==1) )
+				{
+					Scierror(999,"Unique Value must be a logic scalar\n");
+					return 0;
+				}
+				i++;
+				count_unique += 1;
+			}
+			else if(strcmp(arg[0],"MatchThreshold") == 0)
+			{
+				if(count_thresh != 0)
+				{
+					Scierror(999,"Match Threshold argument 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;
+				}
+				//Check for Argument type
+				if( !(isDoubleType(pvApiCtx, piAddr4)) )
+				{
+					Scierror(999,"Match Threshold Value must be a scalar Double\n");
+					return 0;
+				}
+				if(getScalarDouble(pvApiCtx, piAddr4, &thresh))
+				{
+					Scierror(999,"Cannot Read Threshold Value\n");
+					return 0;
+				}
+				if( !(thresh>0 && thresh<=100) )
+				{
+					Scierror(999,"Threshold Value must be in the range of 1 to 100\n");
+					return 0;
+				}
+				i++;
+				count_thresh += 1;
+			}
+			else
+			{
+				Scierror(999, "Invalid Argument Name. Provide Valid Arguments\n");
+				return 0;
+			}	
+		}
+
+		if( count_metric == 0 )
+		{
+			metric = (char**)malloc(sizeof(char*) * 1 * 1);
+			metric[0] = (char*)malloc(sizeof(char) * 4);
+			strcpy(metric[0], "SSD");	
+		}
+		
+		if( count_method == 0)
+		{
+			method = (char**)malloc(sizeof(char*) * 1 * 1);
+			method[0] = (char*)malloc(sizeof(char) * 11);
+			strcpy(method[0], "Exhaustive");	
+		}
+
+		
+		if( strcmp(method[0],"Exhaustive") == 0)
+		{
+			Mat descriptor_1(Rows_1, Cols_1, CV_8UC1);
+			Mat descriptor_2(Rows_2, Cols_2, CV_8UC1);
+		
+			for(int i=0; i<Rows_1; i++)
+				for(int j=0; j<Cols_1; j++)
+				{
+					descriptor_1.at<uchar>(i,j) = int(feature_1[j*Rows_1 + i]);
+				}
+		
+			for(int i=0; i<Rows_2; i++)
+				for(int j=0; j<Cols_2; j++)
+				{
+					descriptor_2.at<uchar>(i,j) = int(feature_2[j*Rows_2 + i]);
+				}
+			if( strcmp(metric[0],"SSD") == 0)
+			{
+				BFMatcher matcher(NORM_L2, int(unique));
+				matcher.match(descriptor_1, descriptor_2, matches);
+			}
+			else if( strcmp(metric[0],"SAD") == 0)
+			{
+				BFMatcher matcher(NORM_L1, int(unique));
+				matcher.match(descriptor_1, descriptor_2, matches);
+			}
+			else if( strcmp(metric[0],"Hamming") == 0)
+			{
+				BFMatcher matcher(NORM_HAMMING, int(unique));
+				matcher.match(descriptor_1, descriptor_2, matches);
+			}
+			else if( strcmp(metric[0],"Hamming_2") == 0)
+			{
+				BFMatcher matcher(NORM_HAMMING2, int(unique));
+				matcher.match(descriptor_1, descriptor_2, matches);
+			}
+			else
+			{
+				Scierror(999,"Enter a Valid value for Metric Argument\n");
+				return 0;
+			}
+		}
+		else if( strcmp(method[0],"Approximate") == 0)
+		{
+			Mat descriptor_1(Rows_1, Cols_1, CV_32FC1);
+			Mat descriptor_2(Rows_2, Cols_2, CV_32FC1);
+		
+			for(int i=0; i<Rows_1; i++)
+				for(int j=0; j<Cols_1; j++)
+				{
+					descriptor_1.at<float>(i,j) = float(feature_1[j*Rows_1 + i]);
+				}
+		
+			for(int i=0; i<Rows_2; i++)
+				for(int j=0; j<Cols_2; j++)
+				{
+					descriptor_2.at<float>(i,j) = float(feature_2[j*Rows_2 + i]);
+				}
+			FlannBasedMatcher matcher;
+			matcher.match(descriptor_1,descriptor_2,matches);	
+		}
+		else
+		{
+			Scierror(999,"Enter a Valid value for Method Argument\n");
+			return 0;
+		}		
+		
+		for( int i=0; i<matches.size(); i++ )
+	  	{ 
+			double dist = matches[i].distance;
+			if( dist > max_dist ) 
+				max_dist = dist;
+  		}
+		min_dist = (thresh * max_dist)/100;	
+
+		for( int i=0; i<matches.size(); i++)
+		{
+			if( matches[i].distance >= min_dist)
+				valid_m.push_back(matches[i]);
+		}
+		indexPairs = (double*)malloc(sizeof(double) * valid_m.size() * 2);
+		for( int i=0; i<valid_m.size(); i++)
+		{
+			indexPairs[i] = valid_m[i].queryIdx+1;
+			indexPairs[valid_m.size() + i] = valid_m[i].trainIdx+1;
+		}
+
+		matchMetric = (double*)malloc(sizeof(double) * valid_m.size());
+		for( int i=0; i<valid_m.size(); i++)
+		{
+			matchMetric[i] = valid_m[i].distance;
+		}		
+
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, valid_m.size(), 2, indexPairs);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+		sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, valid_m.size(), 1, matchMetric);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+
+		free(method);
+
+		ReturnArguments(pvApiCtx);
+		return 0;			
+	}
+}
diff --git a/sci_gateway1/cpp/opencv_medianblur.cpp b/sci_gateway1/cpp/opencv_medianblur.cpp
new file mode 100644
index 0000000..8886af5
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_medianblur.cpp
@@ -0,0 +1,81 @@
+/********************************************************
+    Author: Sukul Bagai
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_medianblur(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k;
+    double ksize;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 2, 2);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image, 1); 
+    //for value of ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &ksize);
+    if(intErr)
+    {
+        return intErr;
+    }   
+
+    Mat new_image(image.rows,image.cols,CV_8UC3);
+    
+    //checking input parameters
+    if((int)ksize != 1 && (int)ksize != 3 && (int)ksize != 5 && (int)ksize != 7)
+    {
+        sciprint("Value of 1,3,5,7 Required for ksize. Default value of 3 was used instead");
+        ksize = 3;
+    }
+    medianBlur(image,new_image,ksize);
+
+    
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_montage.cpp b/sci_gateway1/cpp/opencv_montage.cpp
new file mode 100644
index 0000000..fcb66d7
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_montage.cpp
@@ -0,0 +1,216 @@
+/***************************************************
+Author : Sukul Bagai
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+
+int opencv_montage(char *fname, unsigned long fname_len)
+{
+    SciErr sciErr;
+    int iLen        = 0;
+    //variable info
+    int iRows       = 0;
+    int iCols       = 0;
+    int *piAddr     = NULL;
+    int *piAddr2     = NULL;
+    int *piAddr3     = NULL;
+    int *piAddrChild = NULL;
+    int *piAddrNew  = NULL;
+    int piRows      = 0;
+    int piCols      = 0;        
+    int *piLen      = NULL;
+    char **pstData  = NULL;
+    int **pstData1  = NULL;
+    int i,j,k=0,iItem=0,height,width,intErr=0;
+    double new_rows,new_cols;
+    unsigned char *pstDataR = NULL;
+    unsigned char *pstDataG = NULL;
+    unsigned char *pstDataB = NULL;
+    vector <Mat> image;
+    Mat tempimage;
+
+
+    //Checking number of input and output arguments (enviromnet variable, min arguments, max arguments)
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx,piAddr,&iItem);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    for(int x=0;x<iItem;x++)
+    {
+        sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+        if(sciErr.iErr)   
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getListItemAddress(pvApiCtx,piAddr,x+1,&piAddrChild);
+        if(sciErr.iErr)   
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddrChild, 1, &iRows, &iCols, &pstDataR);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+        if(sciErr.iErr)   
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getListItemAddress(pvApiCtx,piAddr,x+1,&piAddrChild);
+        if(sciErr.iErr)   
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddrChild, 2, &iRows, &iCols, &pstDataG);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+        if(sciErr.iErr)   
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getListItemAddress(pvApiCtx,piAddr,x+1,&piAddrChild);
+        if(sciErr.iErr)   
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, piAddrChild, 3, &iRows, &iCols, &pstDataB);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        tempimage = Mat(iRows,iCols,CV_8UC3);
+        k=0;
+        for(i=0;i<iRows;i++)
+        {
+            for(j=0;j<iCols;j++)
+            {
+              tempimage.at<Vec3b>(i,j)[2]=pstDataR[k];
+              tempimage.at<Vec3b>(i,j)[1]=pstDataG[k];
+              tempimage.at<Vec3b>(i,j)[0]=pstDataB[k++];
+            }
+        }
+        image.push_back(tempimage);
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &new_rows);
+    if(intErr)
+        return intErr;
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if(sciErr.iErr)   
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &new_cols);
+    if(intErr)
+        return intErr;
+
+    for(i=1;i<iItem;i++)
+    {
+        if((image[i].rows != image[i-1].rows) || (image[i].cols != image[i-1].cols))
+        {
+            sciprint("Images not of same size. Montage did not take place\n");
+        }
+    }
+    if( ((new_rows-1)*new_cols >= iItem) || ((new_rows*new_cols) < iItem) )
+    {
+        sciprint("Given Row and Column Dimensions do not match with number of images in list. Montage cannot be created. Please check arguments\n");
+        return 0;
+    }
+    height=new_rows*image[0].rows;
+    width=new_cols*image[0].cols;
+
+    Mat new_image = Mat::zeros(height,width,CV_8UC3);
+
+    k=0;
+    for(int x=0;x<new_rows;x++)
+    {
+        for(int y=0;y<new_cols;y++)
+        {/*
+            if((k)>=iItem)
+            {
+                new_image.at<Vec3b>(image[0].rows*x+i,image[0].cols*y+j)[2]=black_image.at<Vec3b>(i,j)[2];
+                new_image.at<Vec3b>(image[0].rows*x+i,image[0].cols*y+j)[1]=black_image.at<Vec3b>(i,j)[1];
+                new_image.at<Vec3b>(image[0].rows*x+i,image[0].cols*y+j)[0]=black_image.at<Vec3b>(i,j)[0];     
+            }*/
+            if(k<iItem)
+            {
+                for(i=0;i<image[x+y].rows;i++)
+                {
+                    for(j=0;j<image[x+y].cols;j++)
+                    {
+                        new_image.at<Vec3b>(image[k].rows*x+i,image[k].cols*y+j)[2]=image[k].at<Vec3b>(i,j)[2];
+                        new_image.at<Vec3b>(image[k].rows*x+i,image[k].cols*y+j)[1]=image[k].at<Vec3b>(i,j)[1];
+                        new_image.at<Vec3b>(image[k].rows*x+i,image[k].cols*y+j)[0]=image[k].at<Vec3b>(i,j)[0];
+                    }
+                }
+            }
+            k++;
+        }
+    }
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+
+    return 0;
+}
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_morphologyEx.cpp b/sci_gateway1/cpp/opencv_morphologyEx.cpp
new file mode 100644
index 0000000..cc1666a
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_morphologyEx.cpp
@@ -0,0 +1,232 @@
+/***************************************************
+Author : Sukul Bagai
+****************************************************
+Usage : return_image = morphologyEx(input_image,"<op>",kernel_matrix,anchor_x,anchor_y,iterations,"<bordertype>");
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_morphologyEx(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    char **op = NULL;
+    char **borderType = NULL;
+    int i,j,k;
+    double *kernel,anchorX,anchorY,iterations,border;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 7, 7);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for op
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    op = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        op[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, op);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for kernel matrix
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols ,&kernel);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+
+    int n=iRows;
+    double kernelArray[n][n];
+    //assigning values to actual kernelMatrix
+    for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+            kernelArray[i][j]=kernel[(i*n)+j];
+    // converting the array to a matrix, so that we can pass it into the filter2D function    
+    Mat kernelMatrix(n, n, CV_32FC1, &kernelArray);
+
+    //for value of anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &anchorX);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &anchorY);
+    if(intErr)
+        return intErr;
+
+    //for value of iterations
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &iterations);
+    if(intErr)
+        return intErr;
+
+    //for border
+    sciErr = getVarAddressFromPosition(pvApiCtx,7, &piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfString(pvApiCtx, piAddr7, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr7, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr7, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //error check
+    if(anchorX >= n || anchorY >=n)
+    {
+        sciprint("Invalid anchor point given. Centre point (-1,-1) was used instead");
+        anchorY = -1;
+        anchorX = -1;
+    }
+    Mat new_image(image.rows,image.cols,image.type());
+    Point pt(anchorX,anchorY);
+
+    int actualop;
+
+    if(strcmp(op[0],"MORPH_OPEN")==0)
+        actualop=MORPH_OPEN;
+    else if(strcmp(op[0],"MORPH_CLOSE")==0)
+        actualop=MORPH_CLOSE;
+    else if(strcmp(op[0],"MORPH_GRADIENT")==0)
+        actualop=MORPH_GRADIENT;
+    else if(strcmp(op[0],"MORPH_TOPHAT")==0)
+        actualop=MORPH_TOPHAT;
+    else if(strcmp(op[0],"MORPH_BLACKHAT")==0)
+        actualop=MORPH_BLACKHAT;
+    else
+    {
+        sciprint("Invalid type %s used. MORPH_OPEN was used instead by default",op[0]);
+        actualop = MORPH_OPEN;
+    }
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0)
+        border = BORDER_CONSTANT;
+    else if(strcmp(borderType[0], "BORDER_REPLICATE") == 0)
+        border = BORDER_REPLICATE;
+    else if(strcmp(borderType[0], "BORDER_REFLECT") == 0)
+        border = BORDER_REFLECT;
+    else if(strcmp(borderType[0], "BORDER_REFLECT_101") == 0)
+        border = BORDER_REFLECT_101;
+    else if(strcmp(borderType[0], "BORDER_WRAP") == 0)
+        border = BORDER_WRAP;
+    else
+        border = BORDER_DEFAULT;
+
+    //applying function
+    filter2D(image,new_image,actualop,kernelMatrix,pt,iterations,border);
+
+    //returning image
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+    
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_ocr.cpp b/sci_gateway1/cpp/opencv_ocr.cpp
new file mode 100644
index 0000000..dc1dc6d
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_ocr.cpp
@@ -0,0 +1,175 @@
+/***************************************************
+Author : Rohit Suri
+TODO   : Extract confidences for each character
+       : Calculate Position of words
+***************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include <iostream>
+#include <tesseract/baseapi.h>
+using namespace cv; 
+using namespace std;
+using namespace tesseract;
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include "sciprint.h"
+    #include "../common.h"
+    
+    /*Calling syntax: ocr(I) */
+
+    int opencv_ocr(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr; 
+        
+        //------Local variables------//        
+        Mat sourceImage;
+        TessBaseAPI tesseract;
+        int *wordConfidences = NULL;
+        int wordCount = 0, characterCount = 0, count=0, coordinate;
+        string word="";
+        char *text = NULL;
+        char **words = NULL;
+        char *boxInformation = NULL;
+        int *characterBoundingBoxes = NULL;
+        int characterBoundingBoxesPos = 0;
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 1, 1); 
+        CheckOutputArgument(pvApiCtx, 1, 4); 
+        
+        //------Get input arguments------//
+        retrieveImage(sourceImage, 1); 
+                
+        //------Actual processing------//
+        
+        tesseract.Init(NULL, "eng", OEM_TESSERACT_ONLY);
+        tesseract.SetPageSegMode(PSM_SINGLE_BLOCK);
+        tesseract.SetVariable("tessedit_char_whitelist","0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()-_=+[]{}:'\";\|,.<>/");
+        tesseract.SetImage(sourceImage.data, sourceImage.cols, sourceImage.rows, sourceImage.elemSize(), sourceImage.step);
+        wordConfidences = tesseract.AllWordConfidences();
+        boxInformation = tesseract.GetBoxText(0);
+        for(int iter = 0; ;iter++)
+        {
+            if(wordConfidences[iter]!=-1)
+            {
+                wordCount++;
+            }
+            else
+            {
+                break;          
+            }
+        }
+        
+        words = (char**) malloc(sizeof(char*)*wordCount);
+        text = tesseract.GetUTF8Text();
+        for(int iter = 0; count < wordCount; iter++)
+        {
+            
+            if(count == wordCount)
+            {
+                break;
+            }
+            if(text[iter]==' ' || text[iter]=='\n')
+            {
+                words[count] = (char*) malloc(sizeof(char)*word.length()+1);
+                for(int char_iter=0; char_iter<word.length();char_iter++)
+                {
+                    words[count][char_iter] = word[char_iter];
+                }
+                words[count][word.length()] = '\0';
+                word = "";
+                count++;
+                
+            }
+            else
+            {
+                characterCount++;
+                word = word + text[iter];
+            }
+        }
+        characterBoundingBoxes = (int*) malloc(sizeof(int)*characterCount*4);
+        
+        for( int iter = 0; characterBoundingBoxesPos < characterCount ; iter++)
+        {
+            while( boxInformation[iter]!=' ')
+            {
+                iter++;
+            }
+            iter++;
+            coordinate = 0;
+            while(boxInformation[iter]!=' ')
+            {
+                coordinate = 10 * coordinate + boxInformation[iter] - '0';
+                iter++;
+            }
+            characterBoundingBoxes [characterBoundingBoxesPos] = coordinate;
+            coordinate = 0;
+            iter++;
+            while(boxInformation[iter]!=' ')
+            {
+                coordinate = 10 * coordinate + boxInformation[iter] - '0';
+                iter++;
+            }
+            characterBoundingBoxes [characterCount + characterBoundingBoxesPos] = coordinate;
+            coordinate = 0;
+            iter++;
+            while(boxInformation[iter]!=' ')
+            {
+                coordinate = 10 * coordinate + boxInformation[iter] - '0';
+                iter++;
+            }
+            characterBoundingBoxes [2 * characterCount + characterBoundingBoxesPos] = coordinate;
+            coordinate = 0;
+            iter++;
+            while(boxInformation[iter]!=' ')
+            {
+                coordinate = 10 * coordinate + boxInformation[iter] - '0';
+                iter++;
+            }
+            characterBoundingBoxes [3 * characterCount + characterBoundingBoxesPos] = coordinate;
+            characterBoundingBoxesPos++;
+            iter+=2;
+        }
+        //------Create output arguments------//
+        sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 1, &text);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 2, characterCount, 4, characterBoundingBoxes);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 3, wordCount, 1, words);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 4, wordCount, 1, wordConfidences); 
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1; 
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2; 
+        AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3;
+        AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx)+4;
+        ReturnArguments(pvApiCtx); 
+        return 0; 
+    }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_opticalFlowFarneback.cpp b/sci_gateway1/cpp/opencv_opticalFlowFarneback.cpp
new file mode 100644
index 0000000..c6001f0
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_opticalFlowFarneback.cpp
@@ -0,0 +1,553 @@
+/********************************************************************************************************
+              Author : Kevin George
+
+-> Syntax : opticalFlowFarneback("Filename",..,"NumPyramidLevels,..,"PyramidScale",..,
+                                "Num_Iteration",..,"NeighborhoodSize",..,"FilterSize",..)
+
+-> First argument "FileName" is necessary,rest are optional
+*******************************************************************************************************/
+#include <stdio.h>
+#include <iostream>
+#include <opencv2/opencv.hpp>
+#include <opencv2/core/core.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/video/background_segm.hpp>
+#include <unistd.h>
+
+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"
+    // # include "../common.cpp"
+
+    //-> Name,Value Pair Variables
+            char *fileName = NULL; //-> Stores fileName 
+            int NumPyramidLevels;
+            int NeighborhoodSize;
+            int NumIteration;
+            int FilterSize;
+            double PyramidScale;
+    bool objectStatus3 = false;
+
+    int opencv_opticalFlowFarneback    ( char *fname, unsigned long fname_len)
+    {
+
+        //-> Error Management variables
+        SciErr sciErr;
+        int intErr=0;
+
+        //-> Mat containers for images
+        Mat image_1;
+        Mat image_2;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+
+        //-> Local variables
+        int num_InputArgs;  //-> gives total number of arguments
+        int iRows, iCols;
+        int *piLen = NULL;
+        char **pstData = NULL;  //-> why double pointer?? and what is it
+        char *currentArg = NULL; //-> Stores current string representing 'name' of name,value pair arguments
+        bool *providedArgs = NULL; //-> Used to check that optional argument is not entered more than once 
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        //-> Checks number of input and output arguments
+        CheckInputArgument(pvApiCtx, 0  , 5);                     
+        CheckOutputArgument(pvApiCtx, 1, 5);
+
+        //-> Count number of input arguments
+        num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        providedArgs = (bool*) malloc(sizeof(bool) * 6);
+
+//************************************************  Retrieval of Name, Value Argument Pair *************************************************
+        for(int iter = 1; iter<= num_InputArgs; iter++)
+        {
+            //-> Getting address of next argument
+            sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            //-> Extracting name of next argument takes three calls to getMatrixOfString
+            //-> First call to get rows and columns
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+            //-> Second call to retrieve length of each string
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+
+            //-> Third call to retrieve data
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            currentArg = pstData[0];
+            free(pstData);
+            iRows=0;
+            iCols=0;
+            free(piLen);
+
+//****************************************************** Name,Value - NumPyramidLevels *****************************************************************
+ 
+            if(strcmp(currentArg, "FileName")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    //-> Extracting name of next argument takes three calls to getMatrixOfString
+                    //-> First call to get rows and columns
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+                    //-> Second call to retrieve length of each string
+                    sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                
+                    pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+                    for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+                    {
+                        pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+                    }
+
+                    //-> Third call to retrieve data
+                    sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    fileName = pstData[0];
+                    free(pstData);
+                    iRows=0;
+                    iCols=0;
+                    free(piLen);
+                    providedArgs[0] = 1; 
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+            else if(strcmp(currentArg, "NumPyramidLevels")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &NumPyramidLevels); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                    if( NumPyramidLevels < 0)
+                    {
+                        Scierror(999," Invalid Value for NumPyramidLevels. Please enter a non negative Double value\\n");
+                        return 0;
+                    }       
+
+                    providedArgs[1] = 1; 
+                }
+                else if(providedArgs[1]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+//****************************************************** Name,Value - PyramidScale *****************************************************************
+
+            else if(strcmp(currentArg, "PyramidScale")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    if(!isDoubleType(pvApiCtx, piAddr))
+                    {
+                        Scierror(999," Invalid Value for PyramidScale. Please enter a non negative Double value\\n");
+                        return 0;
+                    }
+                    getScalarDouble(pvApiCtx, piAddr, &PyramidScale);
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                    if( PyramidScale < 0)
+                    {
+                        Scierror(999," Invalid Value for NumPyramidLevels. Please enter a non negative Double value\\n");
+                        return 0;
+                    }       
+
+                    providedArgs[2] = 1;    
+                }
+
+                else if(providedArgs[2]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+
+            }
+
+//****************************************************** Name,Value - NumIteration *****************************************************************
+
+            else if(strcmp(currentArg, "NumIteration")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[3])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &NumIteration); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                    if( NumIteration < 0)
+                    {
+                        Scierror(999," Invalid Value for NumPyramidLevels. Please enter a non negative Double value\\n");
+                        return 0;
+                    }       
+
+                    providedArgs[3] = 1; 
+                }
+
+                else if(providedArgs[3]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0;
+                }
+            }
+//****************************************************** Name,Value - NeighborhoodSize *****************************************************************
+
+            else if(strcmp(currentArg, "NeighborhoodSize")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[4])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &NeighborhoodSize); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                    if( NeighborhoodSize < 0)
+                    {
+                        Scierror(999," Invalid Value for size of pixel Neighborhood. Please enter a non negative Double value\\n");
+                        return 0;
+                    }       
+
+                    providedArgs[4] = 1; 
+                }
+
+                else if(providedArgs[4]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0;
+                }
+            }
+//****************************************************** Name,Value - FilterSize *****************************************************************
+
+             else if(strcmp(currentArg, "FilterSize")==0)
+            {
+                if(iter+1<= num_InputArgs && !providedArgs[5])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    intErr = getScalarInteger32(pvApiCtx, piAddr, &FilterSize); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }   
+
+                    //-> Checking if values are in proper range. Same for all optional arguments
+                    if( FilterSize < 0)
+                    {
+                        Scierror(999," Invalid Value for size of pixel Neighborhood. Please enter a non negative Double value\\n");
+                        return 0;
+                    }       
+
+                    providedArgs[5] = 1; 
+                }
+
+                else if(providedArgs[5]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0;
+                }
+            }
+
+            else
+           {
+               Scierror(999, "Incorrect Name type. Please re-enter the correct Name-Value pair arguments\n"); 
+                    return 0;  
+            }
+
+        }//-> Braces for ending of long for loop
+
+//******************************************************** Giving Default Arguments ******************************************************************* 
+
+        if(providedArgs[0] == 0)
+        {
+            NumPyramidLevels = 3;
+        }
+
+
+        if(providedArgs[1] == 0)
+        {
+            PyramidScale = 0.5;
+        }
+
+        if(providedArgs[2] == 0)
+        {
+            NumIteration = 3;
+        }
+
+        if(providedArgs[3] == 0)
+        {
+            NeighborhoodSize = 5;
+        }
+
+        if(providedArgs[4] == 0)
+        {
+            FilterSize = 15;
+        }
+//**************************************************************Actual Processing*******************************************************************************
+
+        objectStatus3 = true;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+
+    int opencv_readopticalFlowFarneback(char *fname, unsigned long fname_len)
+   {
+        SciErr sciErr;
+        int *piAddr = NULL;
+        int *outList = NULL;
+        unsigned char *red = NULL;
+        unsigned char *green = NULL;
+        unsigned char *blue = NULL; 
+
+        if(!objectStatus3)
+        {
+            Scierror(999,"Set up Foreground Detection properties through ForegroundDetection() first.\n");
+            return 0;
+        }
+
+        Mat image_prev, image_next, flow, GetImg, cflow;
+        int s = 2;
+        //char fileName[100] = "ped.avi";
+        //VideoCapture stream1(fileName);   
+        
+        //if(!(stream1.read(GetImg))) //get one frame from video
+         //    return 0;
+        
+         retrieveImage(GetImg,1);
+
+        resize(GetImg, image_prev, Size(GetImg.size().width/s, GetImg.size().height/s) );
+        cvtColor(image_prev, image_prev, CV_BGR2GRAY);
+
+        //namedWindow( "prvs", WINDOW_NORMAL);
+        //namedWindow( "next", WINDOW_NORMAL);
+        namedWindow( "OpticalFlowFarneback", WINDOW_NORMAL);
+
+        //while(true)
+        //{
+            //if(!(stream1.read(GetImg))) //get one frame from video   
+              //  break;
+            
+            retrieveImage(GetImg,2);
+            //-> Resize
+            resize(GetImg, image_next, Size(GetImg.size().width/s, GetImg.size().height/s) );
+            cvtColor(image_next, image_next, CV_BGR2GRAY);
+
+            calcOpticalFlowFarneback(image_prev,image_next, flow, 0.5, 3, 15, 3, 5, 1.2, 0);
+
+            cvtColor(image_prev, cflow, CV_GRAY2BGR);
+            
+            //drawOptFlowMap(flow, cflow, 10, CV_RGB(0, 255, 0));
+            int step = 10;
+            for(int y = 0; y < cflow.rows; y += step)
+            {       
+                for(int x = 0; x < cflow.cols; x += step)
+                {
+                    const Point2f& fxy = flow.at< Point2f>(y, x);
+                    line(cflow, Point(x,y), Point(cvRound(x+fxy.x), cvRound(y+fxy.y)),
+                         CV_RGB(0, 255, 0) );
+                    //circle(cflowmap, Point(cvRound(x+fxy.x), cvRound(y+fxy.y)), 1, color, -1);
+                }
+            }
+
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, &outList);
+            if(sciErr.iErr)
+            {
+                    printError(&sciErr, 0);
+                    return 0;
+            }
+
+            red = (unsigned char *)malloc(sizeof(unsigned char)*cflow.rows*cflow.cols);
+            green = (unsigned char *)malloc(sizeof(unsigned char)*cflow.rows*cflow.cols);
+            blue = (unsigned char *)malloc(sizeof(unsigned char)*cflow.rows*cflow.cols);
+
+            for(int k=0;k<cflow.rows;k++)
+            {
+                for(int p=0;p<cflow.cols;p++)
+                {
+                    Vec3b intensity = cflow.at<Vec3b>(k, p);
+                    red[k+cflow.rows*p]=intensity.val[2];
+                    green[k+cflow.rows*p]=intensity.val[1];
+                    blue[k+cflow.rows*p]=intensity.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, cflow.rows, cflow.cols, red);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 2, cflow.rows, cflow.cols, green);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }                   
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 3, cflow.rows, cflow.cols, blue);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                free(red);
+                free(green);
+                free(blue); 
+
+
+            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;  
+            ReturnArguments(pvApiCtx);
+            return 0;
+
+            //imshow("OpticalFlowFarneback", cflow);
+
+            //->Display
+            //imshow("prvs", image_prev);
+            //imshow("next", image_next);
+
+            //if (waitKey(5) >= 0)   
+              // break;   
+
+          //  image_prev = image_next.clone();
+           // sleep(0.5);
+        //}
+
+          
+   }
+
+ }
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_partition.cpp b/sci_gateway1/cpp/opencv_partition.cpp
new file mode 100644
index 0000000..0c8d37f
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_partition.cpp
@@ -0,0 +1,488 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <string.h>
+#include <iostream>
+#include <stdlib.h>
+#include <time.h>
+using namespace std; 
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include "sciprint.h"
+    
+    /* Calling syntax: [set1,set2,...,setN] = partition(imgSet,groupSizes)
+                       [set1,set2,...,setN] = partition(imgSet,groupPercentages)
+                       [set1,set2,...,setN] = partition(___,method)                   */
+
+    double findSum(double *array, int n)
+    {
+        double sum = 0;
+        for(int iter=0; iter<n; iter++)
+        {
+            sum+= array[iter];
+        }
+        return sum;
+    }
+    
+    int opencv_partition(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr; 
+        
+        //------Local variables------//
+        int *parentAddr = NULL;
+        int *piAddr = NULL;
+        int *piLen = NULL;
+        int *piChild = NULL;
+        int *piGrandChild = NULL;
+        char **pstData = NULL;
+        int iRows, iCols;
+        
+        char *objectType = "imageSet";
+        bool randomized = 0; // 0 for sequential and  1 for randomized method
+        bool sizeProvided; // 0 if percentage and 1 if size provided
+        bool zeroWarning = 0;
+        double *groupSizesOrPercentages = NULL;
+        char **description = NULL;
+        int *count = NULL;
+        int *tempCount = NULL;
+        char ***location = NULL;
+        int **countOutput = NULL;
+        int **locationIndex = NULL;
+        char ***locationOutput = NULL;
+        int descriptionCount, partitionCount;
+        double sumOfSizesOrPercentages;
+        double groupSizesOrPercentagesSum = 0;
+        int index;
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 2, 3);
+        // Output Arguments checked later
+        
+        //------Get input arguments------//
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        if(!isListType(pvApiCtx, piAddr))
+        {
+            Scierror(999, "Error: Invalid first argument. List Expected.\n");
+            return 0;
+        }
+        
+        // Extracting object type and checking if type is imageSet
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 1, &iRows, &iCols, NULL, NULL);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+		sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 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, piAddr, 2, &iRows, &iCols, NULL, NULL);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+		sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 2, &iRows, &iCols, piLen, description);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+        descriptionCount = iRows;
+        
+        // Extracting Count attribute of input argument
+        sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &count);
+        if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+        
+        location = (char***) malloc(sizeof(char**) * descriptionCount);
+        sciErr = getListItemAddress(pvApiCtx, piAddr, 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, &piAddr);
+        if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+        
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &groupSizesOrPercentages);
+        if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+        if(iCols == 0)
+        {
+            Scierror(999, "Error: Please provide a proper groupSizes vector.\n");
+            return 0;
+        }
+        if(iRows!=1)
+        {
+            Scierror(999, "Error: A one dimensional column vector expected.\n");
+            return 0;
+        }
+        partitionCount = iCols+1;
+        CheckOutputArgument(pvApiCtx, 1, partitionCount);
+        
+        if(*getNbInputArgument(pvApiCtx) == 3)
+        {
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+            
+            sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+            for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+            {
+                pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1); 
+            }
+            
+            sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            
+            if(strcmp("sequential",pstData[0])==0)
+            {
+                randomized = 0;
+            }
+            else if(strcmp("randomized",pstData[0])==0)
+            {
+                randomized = 1;
+            }
+            else
+            {
+                Scierror(999, "Error: Argument \"%s\" is not valid.\n",pstData[0]);
+                return 0;
+            }
+        }
+        
+        sumOfSizesOrPercentages = findSum(groupSizesOrPercentages,partitionCount);
+        if(groupSizesOrPercentages[0]>0 && groupSizesOrPercentages[0]<1)
+        {
+            sizeProvided = 0;
+        }
+        else if(groupSizesOrPercentages[0]>=1)
+        {
+            sizeProvided = 1;
+        }
+        else
+        {
+            Scierror(999, "Error: Please enter positive values groupSizes argument.\n");
+            return 0;
+        }
+        for(int iter = 0; iter<partitionCount-1;iter++)
+        {
+            if(sizeProvided && (groupSizesOrPercentages[iter]<1 || groupSizesOrPercentages[iter] - (int)groupSizesOrPercentages[iter]!=0))
+            {
+                Scierror(999, "Error: Please enter positive whole number values for groupSizes argument.\n");
+                return 0;
+            }
+            else if(!sizeProvided && (groupSizesOrPercentages[iter]<=0 || groupSizesOrPercentages[iter]>=1))
+            {
+                Scierror(999, "Error: Please enter proper groupPercentages argument. Values should lie between 0-1.\n");
+                return 0;
+            }
+            groupSizesOrPercentagesSum+=groupSizesOrPercentages[iter]; 
+        }
+        if(!sizeProvided && groupSizesOrPercentagesSum>1)
+        {
+            Scierror(999, "Error: Sum of values of groupPercentages should be less than or equal to one. \n");
+            return 0;
+        }
+        if(sizeProvided)
+        {
+            for(int iter = 0; iter<descriptionCount; iter++)
+            {
+                if(count[iter]<groupSizesOrPercentagesSum)
+                {
+                    Scierror(999, "Error: The sum of groupSizes arguments cannot be greater than the size of any imageSet object.");
+                    return 0;
+                }
+            }
+        }
+        
+        //------Actual processing------//
+        double temp;
+        countOutput = (int**) malloc(sizeof(int*) * partitionCount);
+        tempCount = (int*) malloc(sizeof(int) * descriptionCount);
+        locationIndex = (int**) malloc(sizeof(int*) * descriptionCount);
+        for(int iter = 0 ; iter<descriptionCount; iter++)
+        {
+            locationIndex[iter] = (int*) malloc(sizeof(int) * count[iter]); 
+            tempCount[iter] = count[iter];
+        }
+        for(int iter=0;iter<partitionCount-1; iter++)
+        {
+            countOutput[iter] = (int*) malloc(sizeof(int) * descriptionCount);
+            for(int iter2 = 0; iter2<descriptionCount; iter2++)
+            {
+                if(sizeProvided)
+                {
+                    temp = groupSizesOrPercentages[iter];
+                }
+                else
+                {
+                    temp = groupSizesOrPercentages[iter] * count[iter2];
+                    if(temp - (int)temp >= 0.5)
+                    {
+                        temp = (int)temp + 1;
+                    }
+                    else
+                    {
+                        temp = (int)temp;
+                    }
+                }
+                if(tempCount[iter2]==0)
+                {
+                    countOutput[iter][iter2] = 0;
+                }
+                else if(tempCount[iter2]-temp<=0)
+                {
+                    countOutput[iter][iter2] = tempCount[iter2];
+                    tempCount[iter2] = 0;
+                    zeroWarning = 1;
+                }
+                else
+                {
+                    if(temp==0)
+                    {
+                        zeroWarning = 1;
+                    }
+                    countOutput[iter][iter2] = temp;
+                    tempCount[iter2] -= temp; 
+                }
+            }
+        }
+        countOutput[partitionCount-1] = (int*) malloc(sizeof(int) * descriptionCount);
+        for(int iter = 0; iter<descriptionCount; iter++)
+        {
+            countOutput[partitionCount-1][iter] = tempCount[iter];
+        }
+        for(int iter = 0;iter<descriptionCount;iter++)
+        {
+            for(int iter2=0;iter2<count[iter];iter2++)
+            {
+                locationIndex[iter][iter2] = 0;
+            }
+        }
+        if(randomized)
+        {
+            srand(time(NULL));
+            for(int iter = 0; iter < partitionCount; iter++)
+            {
+                for(int iter2 = 0; iter2 <descriptionCount; iter2++)
+                {
+                    temp = countOutput[iter][iter2];
+                    while(temp!=0)
+                    {
+                        index = rand() % count[iter2];
+                        if(locationIndex[iter2][index]==0)
+                        {
+                            locationIndex[iter2][index] = iter+1;
+                            temp--;
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            for(int iter = 0; iter < partitionCount; iter++)
+            {
+                for(int iter2 = 0; iter2 <descriptionCount; iter2++)
+                {
+                    temp = countOutput[iter][iter2];
+                    index = 0;
+                    while(temp!=0)
+                    {
+                        if(locationIndex[iter2][index]==0)
+                        {
+                            locationIndex[iter2][index] = iter+1;
+                            temp--;
+                        }
+                        index++;
+                    }
+                }
+            }
+        }
+        if(zeroWarning)
+        {
+            sciprint("Warning: One or more sets may have zero images.\n");
+        }
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, partitionCount, &parentAddr);
+	        if(sciErr.iErr)
+	        {
+		        printError(&sciErr, 0);
+		        return 0;
+	        }
+        //------Create output arguments------//
+        for(int iter=1;iter<=partitionCount;iter++)
+        {
+            sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, parentAddr, iter, 4, &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, descriptionCount, 1, description); 
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            sciErr = createMatrixOfInteger32InList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 3, descriptionCount, 1, countOutput[iter-1]);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            sciErr = createListInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 4, descriptionCount, &piChild);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+            locationOutput = (char***) malloc(sizeof(char**) * descriptionCount);
+            for(int i=0;i<descriptionCount;i++)
+            {
+                locationOutput[i] = (char**) malloc(sizeof(char*) * countOutput[iter-1][i]);
+                index = 0;
+                for(int j=0;j<count[i];j++)
+                {
+                    if(locationIndex[i][j]==iter)
+                    {
+                        locationOutput[i][index] = (char*) malloc(sizeof(char) * (strlen(location[i][j])+1));
+                        strncpy(locationOutput[i][index], location[i][j], strlen(location[i][j])+1);
+                        index++;
+                    }
+                }
+                sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piChild, i+1, countOutput[iter-1][i], 1, locationOutput[i]);
+            }
+        }
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        ReturnArguments(pvApiCtx); 
+        return 0; 
+    }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_peopleDetector.cpp b/sci_gateway1/cpp/opencv_peopleDetector.cpp
new file mode 100644
index 0000000..ef8dd5f
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_peopleDetector.cpp
@@ -0,0 +1,468 @@
+/********************************************************
+Author: Suraj Prakash
+[bboxes] = peopleDetector(image)
+
+// 1->image
+
+Optional arguments :
+
+// 2->hitThreshold 
+// 3->winStride
+// 4->padding
+// 5->scale
+// 6->finalThreshold
+// 7->useMeanshiftGrouping
+
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+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"
+  
+  int opencv_peopleDetector(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j;
+    int intErr;
+    int iRows = 0;
+    int iCols = 0;
+    int iRows1 = 0;
+    int iCols1 = 0;
+    
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddr2 = NULL;
+    int *piAddr3 = NULL;
+    char **pstData = NULL;
+    char *currentArg = NULL;
+    bool *providedArgs = NULL; 
+    
+    double hitThreshold = 0;
+    double scale = 1.05; 
+    double *winStride = NULL;
+    double *padding = NULL;
+    double finalThreshold = 2.0;
+    int useMeanshiftGrouping = 0;
+
+    double *bboxes = NULL;
+
+
+    /// for the Hog_SVM_Detector
+    HOGDescriptor hog;
+
+    /// found           -> for the found rectangles 
+    /// found_filtered  -> the size of the rectangles found is usually greater so, the rectangles are filtered out
+    /// bboxes in matlab correspond to found_filtered in this code
+    /// answer to hold the modified rectangle after filtering
+    vector< Rect > found, found_filtered, answer;
+
+    /// checking input argument
+    // 1->image
+    // 2->hitThreshold 
+    // 3->winStride
+    // 4->padding
+    // 5->scale
+    // 6->finalThreshold
+    // 7->useMeanshiftGrouping
+    
+
+    CheckInputArgument(pvApiCtx, 1, 13);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+    /// retrieve image 
+    Mat image;
+    retrieveImage(image, 1);
+
+    /// Train hog detector for people
+    /// Default training is 48 * 96 people images
+    /// can be used for detection of larger instances
+
+
+    /// For the optional arguments
+    int nbInputArguments = *getNbInputArgument(pvApiCtx);
+
+    providedArgs = (bool*) malloc(sizeof(bool) * 5); 
+    memset(providedArgs, 0, 5);
+
+    winStride = (double*)malloc(sizeof(double) * 2);
+    winStride[0] = 8;
+    winStride[1] = 8;
+
+    padding = (double*)malloc(sizeof(double) * 2);
+    padding[0] = 16;
+    padding[1] = 16;
+
+
+    for(int iter = 2; iter <= nbInputArguments; ++iter){
+
+        /// Address of next argument
+        
+        sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        // Three calls to getMatrixOfString
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+        
+        sciErr = getMatrixOfString(pvApiCtx,  piAddr,  &iRows,  &iCols,  piLen,  NULL); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+        for(int k = 0; k < iRows * iCols; ++k)
+        {
+            pstData[k] = (char*) malloc(sizeof(char) * piLen[k] + 1); 
+        }
+        
+        sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, piLen, pstData); 
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        currentArg = pstData[0];         
+
+            /// getting hit_threshold
+            if(strcmp(currentArg, "hitThreshold") == 0)
+            {
+                if(iter + 1 <= nbInputArguments and !providedArgs[0])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &hitThreshold); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    // Checking if values are in proper range. Same for all optional arguments
+                    if(hitThreshold < 0)
+                    {
+                        Scierror(999, "Error: Nonnegative hitThreshold only allowed\n"); 
+                        return 0; 
+                    }
+                    providedArgs[0] = 1; 
+                }
+                else if(providedArgs[0]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            /// WindowStride
+            if(strcmp(currentArg, "winStride") == 0)
+            {
+                if(iter+1 <= nbInputArguments && !providedArgs[1])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows1, &iCols1, &winStride); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows1 != 1 or iCols1 != 2)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument .\n"); 
+                        return 0; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[1] = 1;
+                }
+                else if(providedArgs[1]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            /// Padding
+            if(strcmp(currentArg, "padding") == 0)
+            {
+                if(iter+1 <= nbInputArguments and !providedArgs[2])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows1, &iCols1, &padding); 
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(iRows1 != 1 or iCols1 != 2)
+                    {
+                        Scierror(999, "Incorrect dimension of matrix for argument .\n"); 
+                        return 0; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[2] = 1;
+                }
+                else if(providedArgs[2]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            /// Scalefactor
+            if(strcmp(currentArg, "scale") == 0)
+            {
+                if(iter + 1 <= nbInputArguments and !providedArgs[3])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &scale); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+                    // Checking if values are in proper range. Same for all optional arguments
+                    if(scale < 1.0001)
+                    {
+                        Scierror(999, "Error: Wrong ScaleFactor given. Cannot be less than 1.0001\n"); 
+
+                        return 0; 
+                    }
+                    providedArgs[3] = 1; 
+                }
+                else if(providedArgs[3]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            
+
+            /// finalThreshold
+            if(strcmp(currentArg, "finalThreshold") == 0)
+            {
+                if(iter + 1 <= nbInputArguments and !providedArgs[4])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarDouble(pvApiCtx, piAddr, &finalThreshold); 
+                    if(intErr)
+                    {
+                        return intErr; 
+                    }
+
+                    if(finalThreshold < 0)
+                    {
+                        Scierror(999, "Incorrect value for argument .\n"); 
+                        return 0; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[4] = 1;
+                }
+                else if(providedArgs[4]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+            /// UseMeanshiftGrouping
+            if(strcmp(currentArg, "useMeanshiftGrouping")==0)
+            {
+                if(iter + 1 <= nbInputArguments and !providedArgs[5])
+                {
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr); 
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    intErr = getScalarBoolean(pvApiCtx, piAddr, &useMeanshiftGrouping);  
+                    if(sciErr.iErr)
+                    {
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    if(useMeanshiftGrouping > 1 or useMeanshiftGrouping < 0)
+                    {
+                        Scierror(999, "Incorrect value for argument .\n"); 
+                        return 0; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[5] = 1;
+                }
+                else if(providedArgs[5]) // Send an error message if an argument is provided more than once. Same for all optional arguments.
+                {
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+                else // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+                {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+            }
+
+    }   
+
+    /// End of error check and input get;
+
+    hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());
+
+    ///virtual void cv::HOGDescriptor::detectMultiScale 
+        // ( InputArray  img, 
+        //   std::vector< Rect > &   foundLocations,
+        //   double  hitThreshold = 0,
+        //   Size  winStride = Size(),
+        //   Size  padding = Size(),
+        //   double  scale = 1.05,
+        //   double  finalThreshold = 2.0,
+        //   bool  useMeanshiftGrouping = false 
+        // ) 
+
+    hog.detectMultiScale(image, found, hitThreshold, Size(winStride[0], winStride[1]), Size(padding[0], padding[0]), scale, finalThreshold, useMeanshiftGrouping);
+    
+    /// finding out the rectangles
+    
+    for (i = 0; i < found.size(); ++i){
+        Rect r = found[i];
+        for (j = 0; j < found.size(); ++j)
+            /// removing same identified people
+            if (j != i and (r & found[j]) == r)
+                break;
+
+        /// if no duplicate found
+        if (j == found.size())
+            found_filtered.push_back(r);
+    }
+
+    /// filtering out the rectangles
+    for (i=0; i<found_filtered.size(); i++){
+        Rect r = found_filtered[i];
+        
+        r.x += cvRound(r.width*0.1);
+        r.y += cvRound(r.height*0.06);
+
+        r.width = cvRound(r.width*0.8);
+        r.height = cvRound(r.height*0.9);
+
+        answer.push_back(r);
+    }
+
+    ///  bboxex[i] = [x y width height];
+    bboxes = (double*)malloc(sizeof(double) * (int)answer.size() * 4);
+
+    int total_boxes = (int)answer.size();
+    
+    for(i = 0; i < answer.size(); ++i){
+      Rect temp = answer[i];
+
+      // x coordinate
+      bboxes[i + 0 * total_boxes] = temp.x;
+
+      // y coordinate
+      bboxes[i + 1 * total_boxes] = temp.y;
+
+      // width
+      bboxes[i + 2 * total_boxes] = temp.width;
+
+      // height
+      bboxes[i + 3 * total_boxes] = temp.height;
+    }
+
+   
+
+                                                                                            // rows  // columns
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, total_boxes, 4, bboxes);
+    if(sciErr.iErr){
+      printError(&sciErr, 0);
+      return 0;
+    }
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_predict.cpp b/sci_gateway1/cpp/opencv_predict.cpp
new file mode 100644
index 0000000..51b9710
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_predict.cpp
@@ -0,0 +1,222 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <iostream>
+#include <opencv2/opencv.hpp>
+#include <opencv2/nonfree/nonfree.hpp>
+#include <opencv2/ml/ml.hpp>
+
+using namespace std;
+using namespace cv;
+
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include "sciprint.h"
+    #include "../common.h"
+    int opencv_predict(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr;
+
+        //------Local variables------//
+        int upright = 1;
+        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
+        Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(1, 4, 2, 1, int(upright));
+        BOWImgDescriptorExtractor bowDE(extractor, matcher);
+        SurfFeatureDetector detector(1, 4, 2, 1, int(upright));
+        char *classifierLocation = NULL;
+        Mat dictionary,features;
+        double response;
+        vector<KeyPoint> keyPoints;
+        CvSVM svm;
+        int dictionarySize;
+        int *piAddr = NULL;
+        int *piChild = NULL;
+        int iRows, iCols;
+        char **pstData = NULL;
+        int *piLen = NULL;
+        char **classifierDescription = NULL;
+        int classifierDescriptionCount;
+        char *bagOfFeaturesLocation = NULL;
+        int descriptionCount;
+        Mat input;
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 2, 2);
+        CheckOutputArgument(pvApiCtx, 1, 1);
+
+        //------Get input arguments------//
+        retrieveImage(input,2);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        if(!isListType(pvApiCtx, piAddr))
+        {
+            Scierror(999, "Error: The input argument #1 is not of type classifier.\n");
+            return 0;
+        }
+
+        // Extracting object type and checking if type is classifier
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 1, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 1, &iRows, &iCols, piLen, pstData);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(!(strcmp(pstData[0],"classifier")==0))
+        {
+            Scierror(999, "Error: The input argument #1 is not of type classifier.\n");
+            return 0;
+        }
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 2,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, piLen, pstData);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows!=1 || iCols!=1)
+        {
+            Scierror(999, "1x1 Matrix expected for classifier argument.");
+            return 0;
+        }
+        classifierLocation = pstData[0];
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 3, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 3,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 3, &iRows, &iCols, piLen, pstData);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows!=1 || iCols!=1)
+        {
+            Scierror(999, "1x1 Matrix expected for bagOfFeatures argument.");
+            return 0;
+        }
+        bagOfFeaturesLocation = pstData[0];
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 4, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 4,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        classifierDescription = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            classifierDescription[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 4, &iRows, &iCols, piLen, classifierDescription);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        //------Actual processing------//
+        FileStorage fs(bagOfFeaturesLocation, FileStorage::READ);
+        fs["dictionary"] >> dictionary;
+        fs.release();
+        dictionarySize = dictionary.rows;
+        bowDE.setVocabulary(dictionary);
+        svm.load(classifierLocation);
+        detector.detect(input, keyPoints);
+        bowDE.compute(input, keyPoints, features);
+        response = svm.predict(features);
+        //------Create output arguments------//
+        sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx)+1, 1, 1, &classifierDescription[(int)response]);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    /* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_projectPoints.cpp b/sci_gateway1/cpp/opencv_projectPoints.cpp
new file mode 100644
index 0000000..d242875
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_projectPoints.cpp
@@ -0,0 +1,256 @@
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+#include <iostream>
+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"
+  
+  int opencv_projectPoints(char *fname, unsigned long fname_len)
+  {
+  
+   SciErr sciErr;
+   int intErr=0;
+   int iComplex = 0;
+   int iType = 0;
+   int *piAddr  = NULL;
+   int i,size,j;
+   double *worldPoints=NULL,*rVector=NULL,*tVector=NULL,*intrinsicMatrix=NULL,*distCoefficients=NULL;
+   int wpRows,wpCols,rvRows,rvCols,tvRows,tvCols,imRows,imCols,dcRows,dcCols;
+   double *points=NULL;
+  
+    vector<cv::Point3d> objectPoints;
+    vector<cv::Point2d> imagePoints;
+    Mat intrisicMat(3, 3, cv::DataType<double>::type);
+    Mat rVec(3, 1, cv::DataType<double>::type);
+    Mat tVec(3, 1, cv::DataType<double>::type);
+    Mat distCoeffs(5, 1, cv::DataType<double>::type);
+  
+  	CheckInputArgument(pvApiCtx, 5, 5);
+   CheckOutputArgument(pvApiCtx, 1, 1) ;
+  
+  	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &wpRows, &wpCols, &worldPoints);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+  	if(wpCols!=2)
+  	{
+		Scierror(999, "%s: Wrong value for input argument: World points must be M*2\n");
+		return 0;
+  	}
+  	
+  	sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &rvRows, &rvCols, &rVector);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	if(rvCols!=3)
+	{
+		
+	}
+	sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &tvRows, &tvCols, &tVector);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	if(tvCols!=3)
+	{
+		
+	}
+	if(rvRows!=tvRows)
+	{
+		
+	}
+	
+	sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &imRows, &imCols, &intrinsicMatrix);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	if(imRows!=3 || imCols!=3)
+	{
+		
+	}
+	
+	
+	sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	sciErr = getVarType(pvApiCtx, piAddr, &iType);
+	if(sciErr.iErr || iType != sci_matrix)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	//Get complexity
+	iComplex = isVarComplex(pvApiCtx, piAddr);
+	//Check complexity
+	if(iComplex)
+	{
+		Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+		return 0;
+	}	
+ 	sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &dcRows, &dcCols, &distCoefficients);
+ 	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	if(dcRows!=1 || dcCols!=3)
+	{
+		
+	}
+	
+	for(i=0;i<wpRows;++i)
+	{
+		objectPoints.push_back(cv::Point3d(worldPoints[i],worldPoints[i+wpRows],0));
+	}
+	
+	intrisicMat.at<double>(0, 0) = intrinsicMatrix[0];
+    intrisicMat.at<double>(1, 0) = 0;
+    intrisicMat.at<double>(2, 0) = 0;
+    
+    intrisicMat.at<double>(0, 1) = 0;
+    intrisicMat.at<double>(1, 1) = intrinsicMatrix[4];
+    intrisicMat.at<double>(2, 1) = 0;
+
+    intrisicMat.at<double>(0, 2) = intrinsicMatrix[2];
+    intrisicMat.at<double>(1, 2) = intrinsicMatrix[5];
+    intrisicMat.at<double>(2, 2) = 1;
+
+	rVec.at<double>(0) = rVector[0];
+    rVec.at<double>(1) = rVector[1];
+    rVec.at<double>(2) = rVector[2];
+
+    tVec.at<double>(0) = tVector[0];
+    tVec.at<double>(1) = tVector[1];
+    tVec.at<double>(2) = tVector[2];
+    
+    distCoeffs.at<double>(0) = distCoefficients[0];
+    distCoeffs.at<double>(1) = distCoefficients[1];
+    distCoeffs.at<double>(2) = distCoefficients[2];
+    distCoeffs.at<double>(3) = distCoefficients[3];
+    if(dcCols==5)
+    {
+    	distCoeffs.at<double>(4) = distCoefficients[4];
+    }
+
+	//Actual process
+    projectPoints(objectPoints, rVec, tVec, intrisicMat, distCoeffs, imagePoints);
+    size=imagePoints.size();
+    points = (double*) malloc(sizeof(double) * size * 2);
+    for(i = 0 ; i < size ; i++)
+	{
+		points[i] 	 = imagePoints[i].x;
+		points[i+size] = imagePoints[i].y;
+	}
+	
+	sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, size , 2, points);
+	if(sciErr.iErr)
+	{
+		printError(&sciErr, 0);
+		return 0;
+	}
+	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
+    return 0;
+  }  
+}
diff --git a/sci_gateway1/cpp/opencv_puttext.cpp b/sci_gateway1/cpp/opencv_puttext.cpp
new file mode 100644
index 0000000..97bf62c
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_puttext.cpp
@@ -0,0 +1,311 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   return_image = puttext(image ,x1 ,y1 ,fontscale,r_value,g_value,b_value,text,fontface ,thickness,linetype,bottomleft(0/1));
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_puttext(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piLen2 = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10  = NULL;
+    int *piAddr11 = NULL;
+    int *piAddr12 = NULL;
+    int i,j,k , bottom , fontFace;
+    char **fontface = NULL,**text= NULL;
+    double thickness=1 ,linetype=8,bottomleft ;
+    double x1,y1,fontscale,r_value,g_value,b_value;
+    bool bottomLeftOrigin;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 9, 12);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+    
+    //for value of x coordinate of  point of bootom-left corner of the text string
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&x1);
+     if(intErr)
+      return intErr;
+
+    //for value of y coordinate of point of bootom-left corner of the text string
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&y1);
+    if(intErr)
+      return intErr;
+
+    //for value of fontscale
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&fontscale);
+     if(intErr)
+      return intErr;
+ 
+    //for value of R value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5,&r_value);
+     if(intErr)
+      return intErr;
+  
+      //for value of G value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr) 
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6 ,&g_value);
+    if(intErr)
+      return intErr;
+
+    //for value of Bvalue of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7 ,&b_value);
+    if(intErr)
+      return intErr;
+    
+    /// for text to be written on the image 
+    //Syntax : SciErr getMatrixOfString(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings)
+    //fisrt call to retrieve dimensions
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+   //checking for error if any
+   if (sciErr.iErr)
+   {
+    printError(&sciErr, 0);
+    return 0;
+   }
+    sciErr = getMatrixOfString(pvApiCtx, piAddr8, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr8, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    text = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        text[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr8, &iRows, &iCols, piLen, text);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    ///for the fontface of text
+    sciErr = getVarAddressFromPosition(pvApiCtx,9,&piAddr9);
+    //checking for error if any
+    if (sciErr.iErr)
+    {
+     printError(&sciErr, 0);
+     return 0;
+    }
+     sciErr = getMatrixOfString(pvApiCtx, piAddr9, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    piLen2 = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr9, &iRows, &iCols, piLen2, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    fontface = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        fontface[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr9, &iRows, &iCols, piLen2, fontface);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+   
+    // for thickness of text
+    sciErr = getVarAddressFromPosition(pvApiCtx,10,&piAddr10);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr10,&thickness);
+    if(intErr)
+      return intErr;
+
+   //for line type of text default: 8 
+    sciErr = getVarAddressFromPosition(pvApiCtx,11,&piAddr11);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+  
+    intErr = getScalarDouble(pvApiCtx, piAddr11,&linetype);
+    if(intErr)
+      return intErr;
+
+    // for shift in line defulat : 0
+     sciErr = getVarAddressFromPosition(pvApiCtx,12,&piAddr12);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    intErr = getScalarDouble(pvApiCtx, piAddr12,&bottomleft);
+    if(intErr)
+      return intErr;
+
+   
+    if (bottomleft == 0)
+        bottomLeftOrigin = false;
+    else if (bottomleft == 1)
+        bottomLeftOrigin = true;
+    else
+    {
+       bottomLeftOrigin = false;
+       sciprint("Only 0 and 1 acceptable , taking false instead");  
+    }
+    /// setting fontface  FONT_HERSHEY_SIMPLEX, FONT_HERSHEY_PLAIN, FONT_HERSHEY_DUPLEX, FONT_HERSHEY_COMPLEX, FONT_HERSHEY_TRIPLEX, FONT_HERSHEY_COMPLEX_SMALL,
+    // FONT_HERSHEY_SCRIPT_SIMPLEX, or FONT_HERSHEY_SCRIPT_COMPLEX,
+    if(strcmp(fontface[0],"FONT_HERSHEY_SIMPLEX")==0)
+           fontFace = FONT_HERSHEY_SIMPLEX;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_PLAIN")==0)
+          fontFace= FONT_HERSHEY_PLAIN;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_DUPLEX")==0)
+          fontFace= FONT_HERSHEY_DUPLEX;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_COMPLEX")==0)
+          fontFace= FONT_HERSHEY_COMPLEX;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_TRIPLEX")==0)
+          fontFace = FONT_HERSHEY_TRIPLEX;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_COMPLEX_SMALL")==0)
+          fontFace = FONT_HERSHEY_COMPLEX_SMALL;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_SCRIPT_SIMPLEX")==0)
+         fontFace = FONT_HERSHEY_SCRIPT_SIMPLEX;
+    else if (strcmp(fontface[0],"FONT_HERSHEY_SCRIPT_COMPLEX")==0)
+         fontFace = FONT_HERSHEY_SCRIPT_COMPLEX;
+    else
+    {
+        sciprint("Invalid fontface given. FONT_HERSHEY_PLAIN was used instead");
+        fontFace = FONT_HERSHEY_PLAIN;
+    }
+    //temporary pt variable, to use in function as bottom left corner
+    Point pt1(x1,y1);
+     /// checking the parmeters for correct values   
+    if( r_value <0 || r_value >255)
+     {
+          r_value=0;
+          sciprint(" r value of colour should be between 0 and 255 , using 0 instead");
+     }
+     if( g_value <0 || g_value >255)
+     {
+          g_value=0;
+          sciprint("  g value of colour should be between 0 and 255 , using 0 instead");
+     }
+    if( b_value <0 || b_value >255)
+     {
+          b_value=0;
+          sciprint(" b value of colour should be between 0 and 255 , using 0 instead");
+     }
+    if ((linetype!=0) && (linetype!=4)&& (linetype!=8))
+    {
+             linetype=8;
+             sciprint("Only 0/4/8 allowed , using 8 instead");
+     }
+    
+           
+  
+   //syntax: putText(Mat& img, const string& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false )
+    putText( src, text[0], pt1, fontFace, fontscale, Scalar(b_value,g_value,r_value), thickness, linetype, bottomLeftOrigin );
+
+    string tempstring = type2str(src.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,src,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_pyrDown.cpp b/sci_gateway1/cpp/opencv_pyrDown.cpp
new file mode 100644
index 0000000..7a8df72
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_pyrDown.cpp
@@ -0,0 +1,156 @@
+/***************************************************
+Author : Sukul Bagai
+****************************************************
+  return_image = pyrDown(input_image, dstsize_width, distsize_height, border;
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_pyrDown(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piLen = NULL;
+    char **borderType = NULL;
+    double dstsize_width,dstsize_height;
+    int border;
+    int i;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for value of dstsize_width
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &dstsize_width);
+    if(intErr)
+        return intErr;
+
+    //for value of dstsize_width
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&dstsize_height);
+    if(intErr)
+        return intErr;
+
+    //for border
+    sciErr = getVarAddressFromPosition(pvApiCtx,4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+
+    //error checks
+    if(dstsize_height<0)
+    {
+        sciprint("Positive Value Required for Height. 1 value was used instead\n");
+        dstsize_height=1;
+    }
+    if(dstsize_width<0)
+    {
+        sciprint("Positive Value Required for Width. 1 value was used instead\n");
+        dstsize_width=1;
+    }
+    if((dstsize_width != image.cols*2) && (dstsize_width != image.cols*2+1) && (dstsize_width != image.cols*2-1))
+    {
+        sciprint("Incorrect dstsize_width value was used. src.cols*2+1 value was calculated and used instead\n");
+        dstsize_width = image.cols*2+1;
+    }
+    if((dstsize_height != image.rows*2) && (dstsize_height != image.rows*2+1) && (dstsize_height != image.rows*2-1))
+    {
+        sciprint("Incorrect dstsize_height value was used. src.rows*2+1 value was calculated and used instead\n");
+        dstsize_height = image.rows*2+1;
+    }
+
+    Mat new_image(dstsize_height,dstsize_width,image.type());
+
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0)
+        border = BORDER_CONSTANT;
+    else if(strcmp(borderType[0], "BORDER_REPLICATE") == 0)
+        border = BORDER_REPLICATE;
+    else if(strcmp(borderType[0], "BORDER_REFLECT") == 0)
+        border = BORDER_REFLECT;
+    else if(strcmp(borderType[0], "BORDER_REFLECT_101") == 0)
+        border = BORDER_REFLECT_101;
+    else if(strcmp(borderType[0], "BORDER_WRAP") == 0)
+        border = BORDER_WRAP;
+    else
+        border = BORDER_DEFAULT;
+
+    pyrDown(image,new_image,Size(dstsize_width,dstsize_height),border);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_pyrUp.cpp b/sci_gateway1/cpp/opencv_pyrUp.cpp
new file mode 100644
index 0000000..18459c3
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_pyrUp.cpp
@@ -0,0 +1,156 @@
+/***************************************************
+Author : Sukul Bagai
+****************************************************
+  return_image = pyrUp(input_image, dstsize_width, distsize_height, border;
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_pyrUp(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piLen = NULL;
+    char **borderType = NULL;
+    double dstsize_width,dstsize_height;
+    int border;
+    int i;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for value of dstsize_width
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2, &dstsize_width);
+    if(intErr)
+        return intErr;
+
+    //for value of dstsize_width
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&dstsize_height);
+    if(intErr)
+        return intErr;
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,4, &piAddr4);
+
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+
+    //error checks
+    if(dstsize_height<0)
+    {
+        sciprint("Positive Value Required for Height. 1 value was used instead\n");
+        dstsize_height=1;
+    }
+    if(dstsize_width<0)
+    {
+        sciprint("Positive Value Required for Width. 1 value was used instead\n");
+        dstsize_width=1;
+    }
+    if((dstsize_width != image.cols*2) && (dstsize_width != image.cols*2+1) && (dstsize_width != image.cols*2-1))
+    {
+        sciprint("Incorrect dstsize_width value was used. src.cols*2+1 value was calculated and used instead\n");
+        dstsize_width = image.cols*2+1;
+    }
+    if((dstsize_height != image.rows*2) && (dstsize_height != image.rows*2+1) && (dstsize_height != image.rows*2-1))
+    {
+        sciprint("Incorrect dstsize_height value was used. src.rows*2+1 value was calculated and used instead\n");
+        dstsize_height = image.rows*2+1;
+    }
+
+    Mat new_image(dstsize_height,dstsize_width,image.type());
+
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0)
+        border = BORDER_CONSTANT;
+    else if(strcmp(borderType[0], "BORDER_REPLICATE") == 0)
+        border = BORDER_REPLICATE;
+    else if(strcmp(borderType[0], "BORDER_REFLECT") == 0)
+        border = BORDER_REFLECT;
+    else if(strcmp(borderType[0], "BORDER_REFLECT_101") == 0)
+        border = BORDER_REFLECT_101;
+    else if(strcmp(borderType[0], "BORDER_WRAP") == 0)
+        border = BORDER_WRAP;
+    else
+        border = BORDER_DEFAULT;
+
+    pyrUp(image,new_image,Size(dstsize_width,dstsize_height),border);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_pyramid.cpp b/sci_gateway1/cpp/opencv_pyramid.cpp
new file mode 100644
index 0000000..a158a93
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_pyramid.cpp
@@ -0,0 +1,134 @@
+/********************************************************
+Author: Diwakar Bhardwaj
+*********************************************************
+Usage :return_image=pyramid(input_image,'direction',level)
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_pyramid(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piLen = NULL;
+    char **direction = NULL;
+    int i,j,k=0,l=0;
+    double alpha, beta,x,n;
+    
+     
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    Mat image,new_image;
+    
+    retrieveImage(image, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,2, &piAddr2);
+
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    direction = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        direction[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, direction);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+     sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3 ,&x);
+    if(intErr)
+      return intErr;
+     n=x;
+     k=image.rows;
+     l=image.cols; 
+     while(n--)
+    {
+     
+     //if expand operation is performed
+     if(strcmp(direction[0], "expand") == 0)
+     {   
+          pyrUp(image, new_image, Size( image.cols*2, image.rows*2 ));
+          //Size size((k*2)-1,(l*2)-1); 
+          //resize(image,new_image,size);
+     }
+
+     
+     //if reduced operation is performed
+     else if(strcmp(direction[0], "reduce") == 0)
+    {  
+          pyrDown( image, new_image, Size( image.cols/2, image.rows/2 ));
+          //Size size(k/2,l/2); 
+          //resize(image,new_image,size); 
+     }
+     image=new_image;
+
+    }
+    
+    
+ 
+
+    int temp = nbInputArgument(pvApiCtx) + 1;
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_rectangle.cpp b/sci_gateway1/cpp/opencv_rectangle.cpp
new file mode 100644
index 0000000..36d24f0
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_rectangle.cpp
@@ -0,0 +1,207 @@
+/********************************************************
+    Author: Sukul Bagai 
+*********************************************************
+   return_image = circle(input_image , x_coordinate_of_point1 , y_coordinate_point1, x_coordinate_of_point2 , y_coordinate_point2 , r_value,g_value,b_value,thickness,linetype,shift);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_rectangle(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10  = NULL;
+    int *piAddr11  = NULL;
+    int i,j,k;
+    double thickness=1 , linetype=8,shift =0 ,point1_x ,point1_y,point2_x ,point2_y,r_value,g_value,b_value;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 11, 11);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    
+    Mat src;
+    retrieveImage(src,1);
+   
+    //for value of x coordinate of point1
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&point1_x);
+    if(intErr)
+        return intErr;
+   
+
+    //for value of y coordinate of point1
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&point1_y);
+     if(intErr)
+        return intErr;
+
+    //for value of x coordinate of point2
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4,&point2_x);
+    if(intErr)
+        return intErr;
+   
+
+    //for value of y coordinate of point2
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5,&point2_y);
+     if(intErr)
+        return intErr;
+
+    //for value of R value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6 ,&r_value);
+    if(intErr)
+        return intErr;
+
+      //for value of G value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7 ,&g_value);
+     if(intErr)
+        return intErr;
+
+    // for B value of colour
+    sciErr = getVarAddressFromPosition(pvApiCtx,8,&piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr8,&b_value);
+     if(intErr)
+        return intErr;
+
+    // for thickness of circle  default: 1
+    sciErr = getVarAddressFromPosition(pvApiCtx,9,&piAddr9);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr9,&thickness);
+    if(intErr)
+        return intErr;
+
+      //for line type of circle default: 8 
+    sciErr = getVarAddressFromPosition(pvApiCtx,10,&piAddr10);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+  
+    intErr = getScalarDouble(pvApiCtx, piAddr10,&linetype);
+    if(intErr)
+        return intErr;
+
+ // for shift in circle defulat : 0
+     sciErr = getVarAddressFromPosition(pvApiCtx,11,&piAddr11);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr11,&shift);
+    if(intErr)
+        return intErr;
+   
+    // checking the parmeters for correct values   
+    if( r_value <0 || r_value >255)
+     {
+          r_value=0;
+          sciprint(" r value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+     if( g_value <0 || g_value >255)
+     {
+          g_value=0;
+          sciprint("  g value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if( b_value <0 || b_value >255)
+     {
+          b_value=0;
+          sciprint(" b value of colour should be between 0 and 255 , using 0 instead\n");
+     }
+    if ((linetype!=0) && (linetype!=4)&& (linetype!=8))
+    {
+             linetype=8;
+             sciprint("Only 0/4/8 allowed , using 8 instead\n");
+     }
+
+      // Draw the circles detected
+    rectangle( src, Point(point1_x,point1_y), Point(point2_x,point2_y), Scalar(r_value,g_value,b_value), thickness, linetype, shift);
+     
+//// sending the image
+    string tempstring = type2str(src.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,src,1);
+    free(checker);
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx); 
+    return 0;
+
+
+ }
+
+}
+ 
diff --git a/sci_gateway1/cpp/opencv_rectifyStereoImages.cpp b/sci_gateway1/cpp/opencv_rectifyStereoImages.cpp
new file mode 100644
index 0000000..6b26e27
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_rectifyStereoImages.cpp
@@ -0,0 +1,243 @@
+/********************************************************
+Author: Diwakar Bhardwaj
+*********************************************************
+Usage :[image1,image2] = rectifyStereoImages(input_image1,cameramatrix1,Distortion_coff1,input_image2,cameramatrix2,Distortioncoff2,Translationvector,Rotationvector)
+
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_rectifyStereoImages(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0,iRows2=0,iCols2=0,iRows3=0,iCols3=0,iRows4=0,iCols4=0,iRows5=0,iCols5=0;
+    int iRows6=0,iCols6=0,iRows7=0,iCols7=0,iRows8=0,iCols8=0,iRows9=0,iCols9=0,iRows10=0,iCols10=0;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6  = NULL;
+    int *piAddr7  = NULL;
+    int *piAddr8  = NULL;
+    int *piAddr9  = NULL;
+    int *piAddr10 = NULL;
+    //stereoParams
+    double * D1real = NULL;//Distortion Matrix  5*1
+    double * M1real = NULL;//Camera     Matrix  3*3
+    double * P1real = NULL;//Projection Matrix  3*3
+    double * R1real = NULL;//Rotation   Matrix  3*3
+    double * D2real = NULL;//Distortion Matrix  5*1
+    double * M2real = NULL;//Camera     Matrix  3*3
+    double * P2real = NULL;//Projection Matrix  3*3
+    double * R2real = NULL;//Rotation   Matrix  3*3
+    double * Treal  = NULL;//Translation vector 3*1
+    double * Rreal  = NULL;//Rotation   Matrix 3*3
+    
+    Mat D1(5,1,CV_64F);
+    Mat M1(3,3,CV_64F);
+    Mat D2(5,1,CV_64F);
+    Mat M2(3,3,CV_64F);
+    Mat T (3,1,CV_64F);
+    Mat R (3,3,CV_64F);
+
+    CheckInputArgument(pvApiCtx, 8, 8);
+    CheckOutputArgument(pvApiCtx, 2, 2) ;
+
+    Mat image1,image2;
+    retrieveImage(image1,1);
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows2, &iCols2, &M1real);
+   if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows3, &iCols3, &D1real);
+   if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    retrieveImage(image2,4);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr5, &iRows5, &iCols5, &M2real);
+   if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr6, &iRows6, &iCols6, &D2real);
+   if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 7, &piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr7, &iRows7, &iCols7, &Treal);
+   if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getVarAddressFromPosition(pvApiCtx, 8, &piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr7, &iRows8, &iCols8, &Rreal);
+   if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    if(iRows2!=3 and iCols2!=3 or iRows5!=3 and iCols5!=3)
+    {
+      sciprint("camera matrix  must be size of 3*3");
+    }
+
+    if(iRows3!=1 and iCols3!=5 or iRows6!=1 and iCols6!=5)
+    {
+      sciprint("Distortion cofficient  matrix  must be size of 5*1");
+    }
+    if(iRows7!=1 and iCols7!=3)
+    {
+      sciprint("Translation vector must be 3*1");
+    }
+
+
+    if(iRows8!=3 and iCols8!=3)
+    {
+      sciprint("Rotation Matrix must be 3*3");
+    }
+    
+    for(int i=0;i<3;i++)
+      for(int j=0;j<3;j++)
+             M1.at<double>(i,j)=M1real[i+j*3];
+
+    for(int i=0;i<5;i++)
+             for(int j=0; j<1; ++j)
+                     D1.at<double>(i,j)=D1real[i+j*5];
+    
+    for(int i=0;i<3;i++)
+      for(int j=0;j<3;j++)
+             M2.at<double>(i,j)=M2real[i+j*3];
+
+    for(int i=0;i<5;i++)
+             for(int j=0; j<1; ++j)
+             D2.at<double>(i,j)=D2real[i+j*5];
+
+    for(int i=0; i<3; ++i)
+                for(int j=0; j<1; ++j)
+                    T.at<double>(i,j)=Treal[i+j*3];
+
+    for(int i=0;i<3;i++)
+      for(int j=0;j<3;j++)
+             R.at<double>(i,j)=Rreal[i+j*3];
+    
+    Size imgSize(image1.rows*2,image1.cols*2);
+    Mat R1,R2,P1,P2,Q;
+
+    stereoRectify(M1,D1,M2,D2, imgSize, R, T, R1, R2,P1, P2,  Q);
+
+
+    Mat left, right; //Create matrices for storing input images
+ 
+   // transformation and rectification maps
+    Mat camera1map1, camera1map2;
+    Mat camera2map1, camera2map2;
+    
+    initUndistortRectifyMap(M1, D1, R1, P1, imgSize , CV_32F, camera1map1, camera1map2);
+    initUndistortRectifyMap(M2, D2, R2, P2, imgSize, CV_32F, camera2map1, camera2map2);
+ 
+    Mat leftStereoUndistorted, rightStereoUndistorted;
+    //Rectify and undistort images
+    remap(image1, left, camera1map1, camera1map2, INTER_LINEAR);
+    remap(image2, right, camera2map1, camera2map2, INTER_LINEAR);
+    /*Size size(image1.rows,image1.cols);
+    resize(image1,left,size);
+    Size size1(image2.rows,image2.cols);
+    resize(image2,right,size1);
+     Combining left and right rectified image in one image plane
+    Size sz1 = left.size();
+    Size sz2 = right.size();
+    Mat final_image (sz1.height, sz1.width+sz2.width, CV_8UC3);
+    final_image.adjustROI(0, 0, 0, -sz2.width);
+    left.copyTo(final_image);
+    final_image.adjustROI(0, 0, -sz1.width, sz2.width);
+    right.copyTo(final_image);
+    final_image.adjustROI(0, 0, sz1.width, 0);*/
+ 
+    int temp1 = nbInputArgument(pvApiCtx) + 1;
+    string tempstring1 = type2str(left.type());
+    char *checker1;
+    checker1 = (char *)malloc(tempstring1.size() + 1);
+    memcpy(checker1, tempstring1.c_str(), tempstring1.size() + 1);
+    returnImage(checker1,left,1);
+    free(checker1);
+
+    int temp2 = nbInputArgument(pvApiCtx) + 2;
+    string tempstring2 = type2str(right.type());
+    char *checker2;
+    checker2 = (char *)malloc(tempstring2.size() + 2);
+    memcpy(checker2, tempstring2.c_str(), tempstring2.size() + 2);
+    returnImage(checker2,right,2);
+    free(checker2); 
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_retrieveImages.cpp b/sci_gateway1/cpp/opencv_retrieveImages.cpp
new file mode 100644
index 0000000..cace204
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_retrieveImages.cpp
@@ -0,0 +1,506 @@
+/********************************************************************************************************************************
+* Author: Umang Agrawal                                                                                                         *
+* Code: reteieveImage.cpp                                                                                                       *
+* Funtion Call:    [ Index, Score, ImageWord ] = retrieveImage( QureyImage, IndexImage, OptionalArgument)                       *
+*         Optional Argument:          Name                      Value                                                           *
+*                                   NumResults           Any Value greater than 0                                               *
+*                                     ROI       [ x_coordinate y_coordinate width height ]                                      *
+********************************************************************************************************************************/
+#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"
+#include "opencv2/ml/ml.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 count_based(const vector<int>& a, const vector<int>& b) {
+      return a[1] > b[1];
+  }
+
+	int opencv_retrieveImages(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+
+    int *piAddr = NULL;
+    int *piAddr2 = NULL;
+    int *piAddr3 = NULL;
+    int *piAddr4 = NULL;
+    int *piChild = NULL;
+    int *piGrandChild = NULL;
+    int *piLen = NULL;
+    char **pstData = NULL;
+    int iRows, iCols;
+    int no_item_list = 0;
+    int no_item_list_2 = 0;
+    int inp_params = 0;
+    char **arg = NULL;
+
+    char ***location_img = NULL;
+    double **WordIndex = NULL;
+    double **Location = NULL;
+    double **Vocab_size = NULL;
+    double **Count = NULL;
+    double *wordFrequency = NULL;
+    char *bagOfFeaturesLocation = NULL;
+    int count_res = 0, count_roi = 0;
+    double numRes = 0;
+    double *roi_arg = NULL;
+    double x, y, width, height;
+
+    Mat image;
+    Mat feature_des;
+    Mat dictionary;
+    Mat des_matched;
+    Mat hist;
+    vector<KeyPoint> keypoints;
+    vector<KeyPoint> valid_key;
+    vector< vector<int> > clusterID;
+    vector<int> WordIndex_size;
+
+    int indx;
+    int search_ind;
+    double *Index_Out = NULL;
+    double *Score = NULL;
+    double **ImageWords = NULL;
+
+    CheckInputArgument(pvApiCtx, 2, 6);						//Check on Number of Input Arguments
+		CheckOutputArgument(pvApiCtx, 1, 3);						//Check on Number of Output Arguments
+
+    retrieveImage(image, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    if(!isListType(pvApiCtx, piAddr2))
+    {
+        Scierror(999, "Error: Invalid Second argument. List Expected.\n");
+        return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx, piAddr2, &no_item_list);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 1, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 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, piAddr2, 1, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    if(!(strcmp(pstData[0],"invertedImageIndex")==0))
+    {
+        Scierror(999, "Error: The input argument 2 is not of type invertedImageIndex.\n");
+        return 0;
+    }
+
+    sciErr = getListItemAddress(pvApiCtx, piAddr2, 2, &piChild);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = getListItemNumber(pvApiCtx, piChild, &no_item_list_2);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+    WordIndex = (double**)malloc(sizeof(double*)*no_item_list_2);
+    Location = (double**)malloc(sizeof(double*)*no_item_list_2);
+    Vocab_size = (double**)malloc(sizeof(double*)*no_item_list_2);
+    Count = (double**)malloc(sizeof(double*)*no_item_list_2);
+    for( int i=0; i<no_item_list_2; i++)
+    {
+      sciErr = getListItemAddress(pvApiCtx, piChild, i+1, &piGrandChild);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 1, &iRows, &iCols, &WordIndex[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      WordIndex_size.push_back(iRows);
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 2, &iRows, &iCols, &Location[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 3, &iRows, &iCols, &Vocab_size[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfDoubleInList(pvApiCtx, piGrandChild, 4, &iRows, &iCols, &Count[i]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+    }
+    sciErr = getMatrixOfDoubleInList(pvApiCtx, piAddr2, 3, &iRows, &iCols, &wordFrequency);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 4, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    sciErr = getMatrixOfStringInList(pvApiCtx, piAddr2, 4, &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, piAddr2, 4, &iRows, &iCols, piLen, pstData);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    bagOfFeaturesLocation = pstData[0];
+    if(no_item_list == 5)
+    {
+      location_img = (char***)malloc(sizeof(char**)*1);
+      sciErr = getListItemAddress(pvApiCtx, piAddr2, 5, &piChild);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, 1, &iRows, &iCols, NULL, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, 1, &iRows, &iCols, piLen, NULL);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+      location_img[0] = (char**)malloc(sizeof(char*) * iRows * iCols);
+      for(int colIter = 0 ; colIter < iRows * iCols ; colIter++)
+      {
+        location_img[0][colIter] = (char*)malloc(sizeof(char) * (piLen[colIter] + 1));//+ 1 for null termination
+      }
+      sciErr = getMatrixOfStringInList(pvApiCtx, piChild, 1, &iRows, &iCols, piLen, location_img[0]);
+      if(sciErr.iErr)
+      {
+        printError(&sciErr, 0);
+        return 0;
+      }
+    }
+
+    inp_params = *getNbInputArgument(pvApiCtx);
+    for( int i=3; 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],"NumResuts") == 0)
+      {
+        if(count_res != 0)
+        {
+          Scierror(999,"NumResults Argument 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;
+				}
+				//Checking the type of value
+				if(!(isDoubleType(pvApiCtx, piAddr4)||isIntegerType(pvApiCtx, piAddr4)))
+				{
+					Scierror(999,"Not a valid type of value for NumResults.\n");
+          return 0;
+				}
+        if(getScalarDouble(pvApiCtx, piAddr4, &numRes))
+        {
+          Scierror(999,"Error Reading value of NumResults Argument\n");
+          return 0;
+        }
+        if(numRes < 0)
+        {
+          Scierror(999,"Not a valid value for NumResults\n");
+          return 0;
+        }
+        i++;
+        count_res += 1;
+      }
+      else if(strcmp(arg[0],"ROI") == 0)
+      {
+        if(count_roi != 0)
+        {
+          Scierror(999,"ROI Argument 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;
+				}
+				//Checking the type of argument
+				if(!(isDoubleType(pvApiCtx, piAddr4)||isIntegerType(pvApiCtx, piAddr4)))
+				{
+					Scierror(999,"Not a valid type of value.\n");
+          return 0;
+				}
+				//Reading the Value of the argument
+				sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &roi_arg);
+				if(sciErr.iErr)
+				{
+					printError(&sciErr, 0);
+					return 0;
+				}
+				//Assigning the elements of the list to their proper function
+				x = roi_arg[0];
+				y = roi_arg[1];
+				width = roi_arg[2];
+				height = roi_arg[3];
+        i++;
+        count_roi += 1;
+      }
+      else
+      {
+        Scierror(999,"Invalid Argument Name\n");
+        return 0;
+      }
+    }
+
+    if(count_roi != 0)
+    {
+      Rect masker(x, y, width, height);
+      Mat croppedRef(image, masker);
+      image = Mat();
+      croppedRef.copyTo(image);
+    }
+
+    FileStorage fs(bagOfFeaturesLocation, FileStorage::READ);
+    fs["dictionary"] >> dictionary;
+    fs.release();
+
+    SurfFeatureDetector detector(100, 4, 2, 1, 1);
+    Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
+    Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(100, 4, 2, 1, 1);
+    BOWImgDescriptorExtractor bowDE(extractor, matcher);
+    bowDE.setVocabulary(dictionary);
+    detector.detect(image, keypoints);
+    bowDE.compute(image, keypoints, hist, &clusterID, &des_matched);
+
+    ImageWords = (double**)malloc(sizeof(double*)*4*1);
+    ImageWords[0] = (double*)malloc(sizeof(double)*keypoints.size()*1);
+    ImageWords[1] = (double*)malloc(sizeof(double)*keypoints.size()*2);
+    ImageWords[2] = (double*)malloc(sizeof(double)*1);
+    ImageWords[3] = (double*)malloc(sizeof(double)*1);
+
+    ImageWords[2][0] = Vocab_size[0][0];
+    ImageWords[3][0] = keypoints.size();
+
+    vector<vector<int> > count_index(no_item_list_2 , vector<int>(3));
+
+    for( int i=0; i<keypoints.size(); i++)
+    {
+      ImageWords[1][i] = keypoints[i].pt.x;
+      ImageWords[1][keypoints.size() + i] = keypoints[i].pt.y;
+    }
+    for( int i=0; i<clusterID.size(); i++)
+    {
+      for( int j=0; j<clusterID[i].size(); j++)
+      {
+          indx = clusterID[i][j];
+          ImageWords[0][indx] = i;
+      }
+    }
+
+    for( int i=0; i<no_item_list_2; i++)
+    {
+      int count = 0;
+      for( int j=0; j<keypoints.size(); j++)
+      {
+        search_ind = ImageWords[0][j];
+        for( int k=0; k<WordIndex_size[i]; k++)
+        {
+          if(int(WordIndex[i][k]) == int(search_ind))
+          {
+            count += 1;
+            break;
+          }
+        }
+      }
+      count_index[i][0] = i+1;
+      count_index[i][1] = count;
+      count_index[i][2] = WordIndex_size[i];
+    }
+
+    sort(count_index.begin(), count_index.end(), count_based);
+    if(count_res == 0 || no_item_list_2<numRes)
+      numRes = no_item_list_2;
+    Index_Out = (double*)malloc(sizeof(double)*numRes);
+    Score = (double*)malloc(sizeof(double)*numRes);
+    for( int i=0; i<numRes; i++)
+    {
+      Index_Out[i] = count_index[i][0];
+      Score[i] = double(count_index[i][1])/double(keypoints.size());
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numRes, 1, Index_Out);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, numRes, 1, Score);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, 4, &piAddr);
+    if(sciErr.iErr)
+    {
+      printError(&sciErr, 0);
+      return 0;
+    }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, piAddr, 1, keypoints.size(), 1, ImageWords[0]);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, piAddr, 2, keypoints.size(), 2, ImageWords[1]);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, piAddr, 3, 1, 1, ImageWords[2]);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 3, piAddr, 4, 1, 1, ImageWords[3]);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx)+2;
+    AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx)+3;
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+
+}
diff --git a/sci_gateway1/cpp/opencv_rotationVectorToMatrix.cpp b/sci_gateway1/cpp/opencv_rotationVectorToMatrix.cpp
new file mode 100644
index 0000000..fab0075
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_rotationVectorToMatrix.cpp
@@ -0,0 +1,205 @@
+/***************************************************
+Author : Tanmay Chaudhari
+ **************************************************/
+
+#include <bits/stdc++.h>
+using namespace std;
+extern "C"
+{
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "BOOL.h"
+#include <localization.h>
+#include "sciprint.h"
+
+	int opencv_rotationVectorToMatrix(char *fname, unsigned long fname_len)
+	{
+
+		//Error management variable
+		SciErr sciErr;
+
+		//Variable declaration
+		int iComplex = 0;
+		int iType = 0;
+		int iRows = 0;
+		int iCols = 0;
+		int *piAddr = NULL;
+		double sinOfangle = 0;
+		double cosOfangle = 0;
+		double t, x, y, z;
+		double theta;
+		double *pdbl = NULL;
+		double *matrix;
+		double *identity;
+		double *A;
+		double *B;
+
+		//Check input output arguments
+		checkInputArgument(pvApiCtx, 1, 1);
+		checkOutputArgument(pvApiCtx, 1, 1);
+
+		//Get variable address of the first input argument
+		sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+		if(sciErr.iErr)
+		{		
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Check type
+		sciErr = getVarType(pvApiCtx, piAddr, &iType);
+		if(sciErr.iErr || iType != sci_matrix)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Get complexity
+		iComplex = isVarComplex(pvApiCtx, piAddr);
+
+		//Check complexity
+		if(iComplex)
+		{
+			Scierror(999, "%s: Wrong type for input argument: A complex number is not expected.\n");
+			return 0;
+		}
+
+		sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdbl);
+		if(sciErr.iErr || iCols != 3 || iRows != 1)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		x = pdbl[0];
+		y = pdbl[1];
+		z = pdbl[2];
+
+		theta = sqrt(x * x + y * y + z * z);
+		
+		sinOfangle = sin(theta);
+		cosOfangle = cos(theta);
+		t = 1 - cosOfangle;
+		x = pdbl[0] / theta;
+		y = pdbl[1] / theta;
+		z = pdbl[2] / theta;
+
+		matrix = (double*)malloc(sizeof(double) * 9);
+		A = (double*)malloc(sizeof(double) * 9);
+		B = (double*)malloc(sizeof(double) * 9);
+		identity = (double*)malloc(sizeof(double) * 9);
+		
+		for(int i = 0; i < 3; i++)
+		{
+			for(int j = 0; j < 3; j++)
+			{
+				if(i == 0)
+				{
+					if(j == 0)
+						A[j * 3 + i] = x * x;
+					else if(j == 1)
+						A[j * 3 + i] = x * y;
+					else if(j == 2)
+						A[j * 3 + i] = x * z;
+
+				}
+				else if(i == 1)
+				{
+					if(j == 0)
+						A[j * 3 + i] = x * y;
+					else if(j == 1)
+						A[j * 3 + i] = y * y;
+					else if(j == 2)
+						A[j * 3 + i] = y * z;
+				}
+				else
+				{
+					if(j == 0)
+						A[j * 3 + i] = x * z;
+					else if(j == 1)
+						A[j * 3 + i] = y * z;
+					else if(j == 2)
+						A[j * 3 + i] = z * z;
+				}
+
+			}
+		}
+		
+		for(int i = 0; i < 3; i++)
+		{
+			for(int j = 0; j < 3; j++)
+			{
+				if(i == 0)
+				{
+					if(j == 0)
+						B[j * 3 + i] = 0;
+					else if(j == 1)
+						B[j * 3 + i] = -z;
+					else if(j == 2)
+						B[j * 3 + i] = y;
+
+				}
+				else if(i == 1)
+				{
+					if(j == 0)
+						B[j * 3 + i] = z;
+					else if(j == 1)
+						B[j * 3 + i] = 0;
+					else if(j == 2)
+						B[j * 3 + i] = -x;
+				}
+				else
+				{
+					if(j == 0)
+						B[j * 3 + i] = -y;
+					else if(j == 1)
+						B[j * 3 + i] = x;
+					else if(j == 2)
+						B[j * 3 + i] = 0;
+				}
+
+			}
+		}
+
+		for(int i = 0; i < 3; i++)
+		{
+			for(int j = 0;j < 3; j++)
+			{
+				if(i == j)
+					identity[j * 3 + i] = 1;
+				else
+					identity[j * 3 + i] = 0;
+			}
+		}
+
+		for(int i = 0; i < 3; i++)
+		{
+			for(int j = 0; j < 3; j++)
+			{
+				matrix[i * 3 + j] = identity[j * 3 + i] * cosOfangle + t * A[j * 3 + i] + sinOfangle * B[j * 3 + i];
+			}
+		}
+
+		sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &piAddr);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		sciErr = createMatrixOfDoubleInList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, piAddr, 1, 3, 3, matrix);
+		if(sciErr.iErr)
+		{
+			printError(&sciErr, 0);
+			return 0;
+		}
+
+		//Return output arguments
+		AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+		ReturnArguments(pvApiCtx);
+		return 0;
+	}
+}
+
+
+
diff --git a/sci_gateway1/cpp/opencv_scharr.cpp b/sci_gateway1/cpp/opencv_scharr.cpp
new file mode 100644
index 0000000..cb897d0
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_scharr.cpp
@@ -0,0 +1,155 @@
+/********************************************************
+    Author: Sukul Bagai
+*********************************************************
+   return_image = scharr(input_image, ddepth, dx, dy, scale, delta);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_scharr(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    char **ddepth = NULL;
+    int i,j,k;
+    double dx,dy,scale,delta;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 6, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for ddepth
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    ddepth = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        ddepth[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, ddepth);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for value of dx
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &dx);
+    if(intErr)
+        return intErr;
+
+    //for value of dy
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &dy);
+    if(intErr)
+        return intErr;
+
+    //for value of scale
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &scale);
+    if(intErr)
+        return intErr;
+
+    //for value of delta
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &delta);
+    if(intErr)
+        return intErr;
+
+    Mat new_image(image.rows,image.cols,image.type());
+
+    if(strcmp(ddepth[0],"CV_8U")==0)
+        Scharr(image,new_image,CV_8U,dx,dy,scale,delta);
+    else if(strcmp(ddepth[0],"CV_16U")==0)
+        Scharr(image,new_image,CV_16U,dx,dy,scale,delta);
+    else if(strcmp(ddepth[0],"CV_16S")==0)
+        Scharr(image,new_image,CV_16S,dx,dy,scale,delta);
+    else if(strcmp(ddepth[0],"CV_32F")==0)
+        Scharr(image,new_image,CV_32F,dx,dy,scale,delta);
+    else if(strcmp(ddepth[0],"CV_64F")==0)
+        Scharr(image,new_image,CV_64F,dx,dy,scale,delta);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_sepFilter2D.cpp b/sci_gateway1/cpp/opencv_sepFilter2D.cpp
new file mode 100644
index 0000000..cf3db15
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_sepFilter2D.cpp
@@ -0,0 +1,261 @@
+/***************************************************
+Author : Sukul Bagai
+****************************************************
+Usage : return_image = sepFilter2D(input_image,"<ddepth>",kernel_x,kernel_y,anchor_x,anchor_y,delta,"<bordertype>");
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_sepFilter2D(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    int *piAddr8 = NULL;
+    char **ddepth = NULL;
+    char **borderType = NULL;
+    int i,j,k;
+    double *kernelX,*kernelY,anchorX,anchorY,delta,border,actualddepth;
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 8, 8);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+cout<<"here1";
+    //for ddepth
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    ddepth = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        ddepth[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, ddepth);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for kernel_x matrix
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols ,&kernelX);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+
+    int n;
+
+    if(iRows == 1)
+        n=iCols;
+    else
+        n=iRows;
+    double kernelArray_x[n];
+    //assigning values to actual kernelMatrix
+    for(i=0;i<n;i++)
+            kernelArray_x[i]=kernelX[i];
+    // converting the array to a matrix, so that we can pass it into the filter2D function    
+    Mat kernelMatrix_x(1, n, CV_32FC1, &kernelArray_x);
+
+    //for kernel_y matrix
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols ,&kernelY);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }   
+
+    if(iRows == 1)
+        n=iCols;
+    else
+        n=iRows;
+    double kernelArray_y[n];
+    //assigning values to actual kernelMatrix
+    for(i=0;i<n;i++)
+            kernelArray_y[i]=kernelY[i];
+    
+    // converting the array to a matrix, so that we can pass it into the filter2D function    
+    Mat kernelMatrix_y(1, n, CV_32FC1, &kernelArray_y);
+
+    //for value of anchorX
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &anchorX);
+    if(intErr)
+        return intErr;
+
+    //for value of anchorY
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &anchorY);
+    if(intErr)
+        return intErr;
+
+    //for value of delta
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7, &delta);
+    if(intErr)
+        return intErr;
+
+    //for border
+    sciErr = getVarAddressFromPosition(pvApiCtx,8, &piAddr8);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfString(pvApiCtx, piAddr8, &iRows, &iCols, NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+    //second call to retrieve length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr8, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    borderType = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+    {
+        borderType[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    }
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr8, &iRows, &iCols, piLen, borderType);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //error check
+    if(anchorX >= n || anchorY >=n)
+    {
+        sciprint("Invalid anchor point given. Centre point (-1,-1) was used instead");
+        anchorY = -1;
+        anchorX = -1;
+    }
+    Mat new_image(image.rows,image.cols,image.type());
+    Point pt(anchorX,anchorY);
+
+    if(strcmp(ddepth[0],"CV_8U")==0)
+        actualddepth=CV_8U;
+    else if(strcmp(ddepth[0],"CV_16U")==0)
+        actualddepth=CV_16U;
+    else if(strcmp(ddepth[0],"CV_16S")==0)
+        actualddepth=CV_16S;
+    else if(strcmp(ddepth[0],"CV_32F")==0)
+        actualddepth=CV_32F;
+    else if(strcmp(ddepth[0],"CV_64F")==0)
+        actualddepth=CV_64F;
+    else
+    {
+        sciprint("Invalid type %s used. CV_8U was used instead by default",ddepth[0]);
+        actualddepth = CV_8U;
+    }
+    if(strcmp(borderType[0], "BORDER_CONSTANT") == 0)
+        border = BORDER_CONSTANT;
+    else if(strcmp(borderType[0], "BORDER_REPLICATE") == 0)
+        border = BORDER_REPLICATE;
+    else if(strcmp(borderType[0], "BORDER_REFLECT") == 0)
+        border = BORDER_REFLECT;
+    else if(strcmp(borderType[0], "BORDER_REFLECT_101") == 0)
+        border = BORDER_REFLECT_101;
+    else if(strcmp(borderType[0], "BORDER_WRAP") == 0)
+        border = BORDER_WRAP;
+    else
+        border = BORDER_DEFAULT;
+
+    //applying function
+    sepFilter2D(image,new_image,actualddepth,kernelMatrix_x,kernelMatrix_y,pt,delta,border);
+
+    //returning image
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+    
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_showMatchedFeatures.cpp b/sci_gateway1/cpp/opencv_showMatchedFeatures.cpp
new file mode 100644
index 0000000..ea26e80
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_showMatchedFeatures.cpp
@@ -0,0 +1,275 @@
+/*********************************************************************************
+*Author : Kevin George
+*
+*-> To execute, showMatchedFeatures(I1,I2)
+*   where I1 & I2 are images
+*
+*********************************************************************************/
+#include <numeric>
+#include <string.h>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/nonfree/features2d.hpp"
+#include "opencv2/nonfree/nonfree.hpp"
+#include <iostream>
+#include <math.h>
+#include <vector>
+
+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"
+    // # include "../common.cpp"
+
+    int opencv_showMatchedFeatures(char *fname, unsigned long fname_len)
+    {
+
+    	//-> Error Management variables
+    	SciErr sciErr;
+    	int intErr=0;
+
+        //-> Mat containers for images
+        Mat image_1;
+        Mat image_2;
+
+        //-> Address of Various Arguments
+        int *piAddr = NULL;
+
+        //-> Local variables
+        int minHessian = 400;  //-> For SURF algorithm
+        int num_InputArgs; 
+        //-> KeyPoint is data structure to store a point feature
+        //   detected by a keypoint detector(OpenCV) 
+            vector<KeyPoint> keypoints_1;
+            vector<KeyPoint> keypoints_2;
+        Mat descriptors_1, descriptors_2;
+        Mat img_matches;
+        vector< DMatch > good_matches;
+        vector< DMatch > matches;
+        double max_dist = 0; double min_dist = 100;
+        int *outList = NULL;
+        unsigned char *red = NULL;
+        unsigned char *green = NULL;
+        unsigned char *blue = NULL; 
+        /*double *indexPairs = NULL;
+        double *matchMetric = NULL;
+        double size=1;
+        int iRows, iCols; */
+    
+        //KeyPoint *X = new KeyPoint; //-> Remember to free this Kevin
+
+        //-> Checks the number of arguments
+        //-> pvApiCtx is a Scilab environment pointer
+        CheckInputArgument(pvApiCtx, 2, 5);                     //Check on Number of Input Arguments
+        CheckOutputArgument(pvApiCtx, 1, 5);                    //Check on Number of Output Arguments
+
+    	//-> Read Image
+        retrieveImage( image_1, 1);
+        retrieveImage(image_2, 2);
+
+        //-> Count number of input arguments
+        //num_InputArgs = *getNbInputArgument(pvApiCtx);
+
+        //-> Based on number of input arguments
+
+
+//******************************************************  Retrieval of 3rd,4th,5th args  *******************************************************************
+
+    /*        
+         /*************** Size of good matches **************
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+        sciErr = getScalarDouble(pvApiCtx, piAddr, &size); 
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            } 
+
+        if(getScalarDouble(pvApiCtx, piAddr, &size))
+        {
+            Scierror(999,"Cannot Read Upright Value\n");
+            return 0;
+        }
+
+        vector <DMatch> good_matches(size);   
+   
+
+        /*************** For indexPairs *************
+        sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &indexPairs); 
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+
+        
+            //-> Extract X and Ycoordinates of KeyPoints
+        
+            //X->pt = Point2f(keypoints[i],keypoints[iRows+i]);
+            //keypoints_1.push_back(*X);
+  
+
+        /*************** For matchMetric **************
+        sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr); 
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0); 
+                return 0; 
+            }
+
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &matchMetric); 
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }   
+        
+        for(int i=0; i< size; i++)
+        {
+            good_matches[i].queryIdx = indexPairs[i]; 
+            good_matches[i].trainIdx = indexPairs[ static_cast<int>(size)+i];
+            good_matches[i].distance = matchMetric[i];
+           
+        }
+            */
+        
+//*****************************************************  Actual Processing  *************************************************************
+      
+        //-- Step 1: Calculate keypoints
+        SurfFeatureDetector detector( minHessian );
+        detector.detect( image_1, keypoints_1 );
+        detector.detect( image_2, keypoints_2 );
+
+        //-- Step 2: Calculate descriptors (feature vectors)
+        SurfDescriptorExtractor extractor;
+        extractor.compute( image_1, keypoints_1, descriptors_1 );
+        extractor.compute( image_2, keypoints_2, descriptors_2 );
+
+        //-- Step 3: Matching descriptor vectors using FLANN matcher
+        FlannBasedMatcher matcher;
+        matcher.match( descriptors_1, descriptors_2, matches );
+
+        //-- Quick calculation of max and min distances between keypoints
+        for( int i = 0; i < descriptors_1.rows; i++ )
+        { 
+            double dist = matches[i].distance;
+            if( dist < min_dist ) min_dist = dist;
+            if( dist > max_dist ) max_dist = dist;
+        }
+
+        for( int i = 0; i < descriptors_1.rows; i++ )
+        { 
+            //if( matches[i].distance <= max(2*min_dist, 0.02) )
+            if( matches[i].distance <= (2*min_dist) )
+            { good_matches.push_back( matches[i]); }
+        }
+
+        //-> Draw only "good" matches
+        drawMatches( image_1, keypoints_1, image_2, keypoints_2,
+                good_matches,img_matches, Scalar::all(-1), Scalar::all(-1),
+               vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
+
+        //-> Show detected matches
+        //imshow( "Good Matches", img_matches );
+        //waitKey(0);
+
+        if( img_matches.channels() == 1)
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, &outList);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }
+            red = (unsigned char *)malloc(sizeof(unsigned char)*img_matches.rows*img_matches.cols);
+
+            for(int k=0;k<img_matches.rows;k++)
+                for(int p=0;p<img_matches.cols;p++)
+                    red[k+img_matches.rows*p]=img_matches.at<uchar>(k, p);
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, img_matches.rows, img_matches.cols, red);
+            if(sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 0;
+            }                       
+            free(red);
+        }
+
+        else
+        {
+            sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3, &outList);
+            if(sciErr.iErr)
+            {
+                    printError(&sciErr, 0);
+                    return 0;
+            }
+
+            red = (unsigned char *)malloc(sizeof(unsigned char)*img_matches.rows*img_matches.cols);
+            green = (unsigned char *)malloc(sizeof(unsigned char)*img_matches.rows*img_matches.cols);
+            blue = (unsigned char *)malloc(sizeof(unsigned char)*img_matches.rows*img_matches.cols);
+
+            for(int k=0;k<img_matches.rows;k++)
+            {
+                for(int p=0;p<img_matches.cols;p++)
+                {
+                    Vec3b intensity = img_matches.at<Vec3b>(k, p);
+                    red[k+img_matches.rows*p]=intensity.val[2];
+                    green[k+img_matches.rows*p]=intensity.val[1];
+                    blue[k+img_matches.rows*p]=intensity.val[0];
+                }
+            }
+
+            sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 1, img_matches.rows, img_matches.cols, red);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 2, img_matches.rows, img_matches.cols, green);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }                   
+                sciErr = createMatrixOfUnsignedInteger8InList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, outList, 3, img_matches.rows, img_matches.cols, blue);
+                if(sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 0;
+                }
+                free(red);
+                free(green);
+                free(blue); 
+
+        }
+
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+
+}
diff --git a/sci_gateway1/cpp/opencv_sobel.cpp b/sci_gateway1/cpp/opencv_sobel.cpp
new file mode 100644
index 0000000..912be4d
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_sobel.cpp
@@ -0,0 +1,172 @@
+/********************************************************
+    Author: Sukul Bagai
+*********************************************************
+   return_image = sobel(input_image, ddepth, dx, dy, kszie, scale, delta);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_sobel(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr = 0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int *piAddr6 = NULL;
+    int *piAddr7 = NULL;
+    char **ddepth = NULL;
+    int i,j,k;
+    double dx,dy,ksize,scale,delta;
+
+
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 7, 7);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    Mat image;
+    retrieveImage(image,1);
+
+    //for value of ddepth
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    //Now, we will retrieve the string from the input parameter. For this, we will require 3 calls
+    //first call to retrieve dimensions
+    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 length of each string
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    ddepth = (char**)malloc(sizeof(char*) * iRows * iCols);
+    for(i = 0 ; i < iRows * iCols ; i++)
+        ddepth[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+    //third call to retrieve data
+    sciErr = getMatrixOfString(pvApiCtx, piAddr2, &iRows, &iCols, piLen, ddepth);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    //for value of dx
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3, &dx);
+    if(intErr)
+        return intErr;
+
+    //for value of dy
+    sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr4, &dy);
+    if(intErr)
+        return intErr;
+
+    //for value of ksize
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr5, &ksize);
+    if(intErr)
+        return intErr;
+
+    //for value of scale
+    sciErr = getVarAddressFromPosition(pvApiCtx,6,&piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr6, &scale);
+    if(intErr)
+        return intErr;
+
+    //for value of delta
+    sciErr = getVarAddressFromPosition(pvApiCtx,7,&piAddr7);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr7, &delta);
+    if(intErr)
+        return intErr;
+
+    Mat new_image(image.rows,image.cols,CV_8UC3);
+    if((int)ksize!=1 && (int)ksize!=3 && (int)ksize!=5 && (int)ksize!=7)
+    {
+        sciprint("Value of 1,3,5,7 Required for ksize. Default value of 3 was used instead");
+        ksize=3;
+    }
+
+    //void Sobel(InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT )
+    if(strcmp(ddepth[0],"CV_8U")==0)
+        Sobel(image,new_image,CV_8U,dx,dy,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_16U")==0)
+        Sobel(image,new_image,CV_16U,dx,dy,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_16S")==0)
+        Sobel(image,new_image,CV_16S,dx,dy,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_32F")==0)
+        Sobel(image,new_image,CV_32F,dx,dy,ksize,scale,delta);
+    else if(strcmp(ddepth[0],"CV_64F")==0)
+        Sobel(image,new_image,CV_64F,dx,dy,ksize,scale,delta);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_threshold.cpp b/sci_gateway1/cpp/opencv_threshold.cpp
new file mode 100644
index 0000000..1210d47
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_threshold.cpp
@@ -0,0 +1,146 @@
+/********************************************************
+    Author: Abhilasha Sancheti & Sukul Bagai
+*********************************************************
+   [return_image, double] = threshold(input_image, threshold_value, max_value, "<threshold_type>");
+********************************************************/
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <math.h>
+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"
+  
+  int opencv_threshold(char *fname, unsigned long fname_len)
+  {
+
+    SciErr sciErr;
+    int intErr=0;
+    int iRows=0,iCols=0;
+    int *piLen = NULL;
+    int *piAddr = NULL;
+    int *piAddrNew = NULL;
+    int *piAddrNew2 = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int i,j,k;
+    double thresh,max_val;
+    int type; 
+    char **gettype = NULL;
+    
+    //checking input argument
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 2, 2) ;
+    Mat image;
+    retrieveImage(image,1);
+    if(no_of_channels(image.type()) != 1)
+        cvtColor( image, image, CV_BGR2GRAY );
+    
+    
+    //for threshold value (thresh)
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr2,&thresh);
+    if(intErr)
+        return intErr;
+
+    //for max_value
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    intErr = getScalarDouble(pvApiCtx, piAddr3,&max_val);
+    if(intErr)
+        return intErr;
+
+
+// for type of thresholding (gettype)
+       sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+     //checking for error if any
+       if (sciErr.iErr)
+       {
+        printError(&sciErr, 0);
+        return 0;
+       }
+       sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, NULL, NULL);
+       piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+       //second call to retrieve length of each string of first argument
+       sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, NULL);
+       if(sciErr.iErr)
+       {
+          printError(&sciErr, 0);
+          return 0;
+       }
+       gettype= (char**)malloc(sizeof(char*) * iRows * iCols);
+       for(i = 0 ; i < iRows * iCols ; i++)
+       {
+           gettype[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
+       }
+       //third call to retrieve data of each string of first argument
+       sciErr = getMatrixOfString(pvApiCtx, piAddr4, &iRows, &iCols, piLen, gettype);
+       if(sciErr.iErr)
+       {
+          printError(&sciErr, 0);
+          return 0;
+       }
+    //for value of type
+  
+    Mat new_image(image.rows,image.cols,CV_8UC1);
+     if(strcmp(gettype[0],"THRESH_BINARY")==0)
+           type = 0;
+    else if (strcmp(gettype[0],"THRESH_BINARY_INV")==0)
+          type=1;
+    else if (strcmp(gettype[0],"THRESH_TRUNC")==0)
+          type=2;
+    else if (strcmp(gettype[0],"THRESH_TOZERO")==0)
+          type=3;
+    else if (strcmp(gettype[0],"THRESH_TOZERO_INV")==0)
+          type=4;
+    else
+    {
+    	sciprint("Wrong type given. THRESH_BINARY used instead");
+    	type=0;
+    }
+    double res = threshold( image ,new_image, thresh, max_val,type);
+    // Converting resultant image to 3D matrix
+    int temp = nbInputArgument(pvApiCtx) + 1;
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker);
+
+    intErr = createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2,res);
+    if(intErr)
+    {
+        return intErr;
+    }
+   
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+        //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_trainImageCategoryClassifier.cpp b/sci_gateway1/cpp/opencv_trainImageCategoryClassifier.cpp
new file mode 100644
index 0000000..e2a504a
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_trainImageCategoryClassifier.cpp
@@ -0,0 +1,349 @@
+/***************************************************
+Author : Rohit Suri
+***************************************************/
+#include <iostream>
+#include <opencv2/opencv.hpp>
+#include <opencv2/nonfree/nonfree.hpp>
+#include <opencv2/ml/ml.hpp>
+
+using namespace std;
+using namespace cv;
+
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include "sciprint.h"
+    int opencv_trainImageCategoryClassifier(char *fname, unsigned long fname_len)
+    {
+        // Error management variables
+        SciErr sciErr;
+
+        //------Local variables------//
+        int upright = 1;
+        Ptr<DescriptorMatcher> matcher = DescriptorMatcher::create("FlannBased");
+        Ptr<DescriptorExtractor> extractor = new SurfDescriptorExtractor(1, 4, 2, 1, int(upright));
+        BOWImgDescriptorExtractor bowDE(extractor, matcher);
+        SurfFeatureDetector detector(1, 4, 2, 1, int(upright));
+        char *fileName = NULL;
+        Mat dictionary,inp,features;
+        vector<KeyPoint> keyPoints;
+
+
+        int *piAddr = NULL;
+        int *piChild = NULL;
+        int iRows, iCols;
+        char **pstData = NULL;
+        int *piLen = NULL;
+        int *count = NULL;
+        char **description = NULL;
+        char ***location = NULL;
+        char *bagOfFeaturesLocation = NULL;
+        int descriptionCount;
+        char *classifierLocation = "classifier.yml";
+        char *objectType = "classifier";
+        //------Check number of parameters------//
+        CheckInputArgument(pvApiCtx, 2, 2);
+        CheckOutputArgument(pvApiCtx, 1, 1);
+
+        //------Get input arguments------//
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        if(!isListType(pvApiCtx, piAddr))
+        {
+            Scierror(999, "Error: The input argument #1 is not of type imageSet.\n");
+            return 0;
+        }
+
+        // Extracting object type and checking if type is imageSet
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 1, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 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 #1 is not of type imageSet.\n");
+            return 0;
+        }
+
+        // Extracting Description attribute of input argument
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 2, &iRows, &iCols, piLen, description);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        descriptionCount = iRows;
+
+        // Extracting Count attribute of input argument
+        sciErr = getMatrixOfInteger32InList(pvApiCtx, piAddr, 3, &iRows, &iCols, &count);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        location = (char***) malloc(sizeof(char**) * descriptionCount);
+        sciErr = getListItemAddress(pvApiCtx, piAddr, 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;
+            }
+        }
+        // Second argument
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        if(!isListType(pvApiCtx, piAddr))
+        {
+            Scierror(999, "Error: The input argument #2 is not of type bagOfFeatures.\n");
+            return 0;
+        }
+
+        // Extracting object type and checking if type is bagOfFeatures
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 1, &iRows, &iCols, NULL, NULL);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*)malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 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, piAddr, 1, &iRows, &iCols, piLen, pstData);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(!(strcmp(pstData[0],"bagOfFeatures")==0))
+        {
+            Scierror(999, "Error: The input argument #2 is not of type bagOfFeatures.\n");
+            return 0;
+        }
+        // Extracting name of next argument takes three calls to getMatrixOfString
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, NULL, NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols);
+
+        sciErr = getMatrixOfStringInList(pvApiCtx,  piAddr, 2,  &iRows,  &iCols,  piLen,  NULL);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols);
+        for(int iterPstData = 0; iterPstData < iRows * iCols; iterPstData++)
+        {
+            pstData[iterPstData] = (char*) malloc(sizeof(char) * piLen[iterPstData] + 1);
+        }
+
+        sciErr = getMatrixOfStringInList(pvApiCtx, piAddr, 2, &iRows, &iCols, piLen, pstData);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows!=1 || iCols!=1)
+        {
+            Scierror(999, "1x1 Matrix expected for bagOfFeatures argument.");
+            return 0;
+        }
+        bagOfFeaturesLocation = pstData[0];
+        //------Actual processing------//
+        FileStorage fs(bagOfFeaturesLocation, FileStorage::READ);
+        fs["dictionary"] >> dictionary;
+        fs.release();
+        if(dictionary.rows==0 || dictionary.cols==0)
+        {
+            sciprint("Error: The provided file for bagOfFeatures may be invalid.\n");
+        }
+        sciprint("Training an image category classifier for %d categories.\n",descriptionCount);
+        sciprint("-------------------------------------------------------\n\n");
+        for(int i=0;i<descriptionCount;i++)
+        {
+            sciprint("# Category %d: %s\n",i+1,description[i]);
+        }
+        sciprint("\n");
+        int dictionarySize = dictionary.rows;
+        Mat labels(0, 1, CV_32FC1);
+        Mat trainingData(0, dictionarySize, CV_32FC1);
+        bowDE.setVocabulary(dictionary);
+        for(int i=0; i<descriptionCount;i++)
+        {
+            sciprint("# Encoding features for Category %d ...",i+1);
+            for(int j=0; j<count[i]; j++)
+            {
+                features.release();
+                keyPoints.clear();
+                fileName = location[i][j];
+                inp = imread(fileName);
+                detector.detect(inp,keyPoints);
+                bowDE.compute(inp,keyPoints,features);
+                trainingData.push_back(features);
+                labels.push_back((float) i);
+            }
+            sciprint("done.\n");
+        }
+        sciprint("\n# Training the category classifier...");
+        CvSVMParams params;
+        params.kernel_type=CvSVM::RBF;
+        params.svm_type=CvSVM::C_SVC;
+        params.gamma=0.50625000000000009;
+        params.C=312.50000000000000;
+        params.term_crit=cvTermCriteria(CV_TERMCRIT_ITER,100,0.000001);
+        CvSVM svm;
+        svm.train(trainingData,labels,cv::Mat(),cv::Mat(),params);
+        svm.save(classifierLocation);
+        sciprint("done.\n");
+        //------Create output arguments------//
+        sciErr = createList(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 4, &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, &classifierLocation);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 3, 1, 1, &bagOfFeaturesLocation);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+        sciErr = createMatrixOfStringInList(pvApiCtx, nbInputArgument(pvApiCtx)+1, piAddr, 4, descriptionCount, 1, description);
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        //------Return Arguments------//
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx)+1;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    /* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_triangulatePoints.cpp b/sci_gateway1/cpp/opencv_triangulatePoints.cpp
new file mode 100644
index 0000000..4ee38bd
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_triangulatePoints.cpp
@@ -0,0 +1,166 @@
+/***************************************************
+Author : Deepshikha
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include "opencv2/calib3d/calib3d.hpp"
+#include <iostream>
+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"
+  
+  int opencv_triangulatePoints(char *fname, unsigned long fname_len)
+  {
+    //variables
+    int i,j,n,m;
+    int iRows=0,iCols=0;
+    int *piAddr1  = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    
+    double *pdblReal = NULL;
+
+    SciErr sciErr;
+
+    /*------------------------------------------- Checking Input Argument ----------------------------------------------------*/
+    
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    /*------------------------------------- Projection matrix 1 :- First argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(iRows!=3 or iCols!=4){
+        Scierror(iRows,"Projection matrix (arg 1)  must be a 3 X 4 matrix");
+        return 0;
+    }
+    Mat projMat1(iRows, iCols, CV_64F);
+    for(i = 0; i < iRows; i++)
+        for(j = 0; j < iCols; j++){
+           projMat1.at<double>(i,j) = pdblReal[i + (j * iRows)];
+        }
+    
+    /* ------------------------------------ Projection matrix 2 :- Second argument of the input -------------------------------------*/
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(iRows!=3 or iCols!=4){
+        Scierror(iRows,"Projection matrix (arg 2)  must be a 3 X 4 matrix");
+        return 0;
+    }
+    Mat projMat2(iRows, iCols, CV_64F);
+    for(i=0;i<iRows;i++)
+        for(j=0;j<iCols;j++)
+            projMat2.at<double>(i,j) = pdblReal[i + (j * iRows)];
+
+
+    /* ------------------------------------ Points matrix 1 :- Third argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    n = iCols;
+    if(iRows!=2){
+        Scierror(iRows,"Points matrix (arg 3) must be a 2 X N matrix");
+        return 0;
+    }
+    Mat newPoint1(2, iCols, CV_64F);
+    for(i = 0; i < 2; i++)
+        for(j = 0; j < iCols; j++)
+            newPoint1.at<double>(i,j) = pdblReal[ i + ( j * iRows )];
+    
+
+    /* ------------------------------------ Points matrix 2 :- Fourth argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    
+    m = iCols;
+    if(iRows!=2){
+        Scierror(iRows,"Points matrix (arg 4) must be a 2 X N matrix");
+        return 0;
+    }
+    Mat newPoint2(iRows, iCols, CV_64F);
+    for(i = 0; i < iRows; i++)
+        for(j = 0; j < iCols; j++)
+            newPoint2.at<double>(i,j) = pdblReal[ i + ( j * iRows )];
+
+    if(n!=m){
+        Scierror(n,"No of columns of arg 3 and arg 4 must be same");
+        return 0;
+    }
+    Mat new_image(4, n, CV_64F);
+
+    triangulatePoints(projMat1, projMat2, newPoint1, newPoint2, new_image);
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_undistort.cpp b/sci_gateway1/cpp/opencv_undistort.cpp
new file mode 100644
index 0000000..da72d8e
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_undistort.cpp
@@ -0,0 +1,118 @@
+/***************************************************
+Author : Sukul Bagai, Shubheksha Jalan
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+using namespace cv;
+using namespace std;
+extern "C"
+{
+  #include "api_scilab.h"
+  #include "Scierror.h"
+  #include "BOOL.h"
+  #include <localization.h>
+  #include "../common.h"
+  
+  int opencv_undistort(char *fname, unsigned long fname_len)
+  {
+    SciErr sciErr;
+    int iRows=0,iCols=0;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    int i,j,k;
+    double cameraMatrix [3][3], newCameraMatrix [3][3];
+    double *temp = NULL;
+ //checking input argument
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+    Mat image;
+    retrieveImage(image, 1); 
+
+	//for camera matrix 
+    sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &temp);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    for(i=0;i<3;i++)
+        for(j=0;j<3;j++)
+            cameraMatrix[i][j]=temp[(j*3)+i];
+   Mat cameraMat(3,3,CV_64F,&cameraMatrix);
+
+//for array of coefficients
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols, &temp);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    int n;
+    if(iRows==1)
+        n=iCols;
+    else
+        n=iRows;
+    
+    double distCoeffs[n];
+    for(i=0;i<n;i++)
+        distCoeffs[i]=temp[i];
+    Mat distCoeffsActual(n,1,CV_64F);
+
+//for optional parameter newCameraMatrix
+sciErr = getVarAddressFromPosition(pvApiCtx,4,&piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols , &temp);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    } 
+
+    for(i=0;i<3;i++)
+        for(j=0;j<3;j++)
+            newCameraMatrix[i][j]=temp[(j*3)+i];  
+  Mat newCameraMat(3,3,CV_64F,&newCameraMatrix);
+  Mat new_image;
+
+  undistort(image, new_image, cameraMat, distCoeffsActual, newCameraMat);
+
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker,new_image,1);
+    free(checker); 
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/opencv_undistortImage.cpp b/sci_gateway1/cpp/opencv_undistortImage.cpp
new file mode 100644
index 0000000..9a02882
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_undistortImage.cpp
@@ -0,0 +1,271 @@
+/********************************************************
+Author: Suraj Prakash
+return_image = undistortImage(image, _cameraMatrix, _distCoeffs, _newCameraMatrix);
+********************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+#include <vector>
+
+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"
+  
+  int opencv_undistortImage(char *fname, unsigned long fname_len){
+
+    /// Error management variable
+    SciErr sciErr;
+    
+    /// Variables
+    int i, j, n = 0;
+
+    int iRows = 0;
+    int iCols = 0;
+    int iRows1 = 0;
+    int iCols1 = 0;
+    int *piLen = NULL;
+    int *piAddr2 = NULL;
+    int *piAddr3 = NULL;
+    int *piAddr4 = NULL;
+    double *pdblReal = NULL;
+ 
+    char **pstData = NULL;
+    char *currentArg = NULL;
+    bool *providedArgs = NULL; 
+
+    double cameraMatrix[3][3]; 
+    double *newCameraMatrix = NULL;
+    double *distCoeffs = NULL;
+
+    /// checking input argument
+    //  1-> image
+    //  2-> cameraMatrix
+    //  3-> distCoeffs
+    //  4-> newCameraMatrix
+
+    CheckInputArgument(pvApiCtx, 2, 6);
+    CheckOutputArgument(pvApiCtx, 1, 1);
+
+    /// Take distorted image
+    Mat image;
+    retrieveImage(image, 1);
+
+    newCameraMatrix = (double*)malloc(sizeof(double) * 3 * 3);
+    memset(newCameraMatrix, 0, sizeof(newCameraMatrix));
+
+    /// Taking input for cameraMatrix
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr){
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    /// Take input in cameraMatrix
+    Mat _cameraMatrix(3, 3, CV_64F);
+    for(i = 0; i < 3; ++i)
+        for(j = 0;j < 3; ++j)
+            _cameraMatrix.at<double>(i, j) = pdblReal[(j * 3) + i];
+    
+
+    int nbInputArguments = *getNbInputArgument(pvApiCtx);
+
+
+    providedArgs = (bool*) malloc(sizeof(bool) * 2);
+    memset(providedArgs, 0, 2);
+ 
+    for(int iter = 3; iter <= nbInputArguments; ++iter){
+
+        /// Address of next argument
+        
+        sciErr = getVarAddressFromPosition(pvApiCtx, iter, &piAddr3); 
+        if (sciErr.iErr){
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        // Three calls to getMatrixOfString
+        sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, NULL, NULL); 
+        if (sciErr.iErr){
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        piLen = (int*) malloc(sizeof(int) * iRows * iCols); 
+        
+        sciErr = getMatrixOfString(pvApiCtx,  piAddr3,  &iRows,  &iCols,  piLen,  NULL); 
+        if (sciErr.iErr){
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+        
+        pstData = (char**) malloc(sizeof(char*) * iRows * iCols); 
+        for(int k = 0; k < iRows * iCols; ++k)
+        {
+            pstData[k] = (char*) malloc(sizeof(char) * piLen[k] + 1); 
+        }
+        
+        sciErr = getMatrixOfString(pvApiCtx, piAddr3, &iRows, &iCols, piLen, pstData); 
+        if (sciErr.iErr){
+            printError(&sciErr, 0); 
+            return 0; 
+        }
+
+        currentArg = pstData[0]; 
+
+        if(strcmp(currentArg, "distCoeffs") == 0){
+
+            if(iter+1 <= nbInputArguments and !providedArgs[0]){
+                    
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr4); 
+                    
+                    if (sciErr.iErr){
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows1, &iCols1, &pdblReal); 
+                    
+                    if(sciErr.iErr){
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    if(iRows1 == 1 or iCols1 == 1)
+                      n = iCols1 * iRows1;
+                    
+                    else{
+                        Scierror(999, "Incorrect dimension of vector for argument\n"); 
+                        return 0; 
+                    }
+
+                    // if(n != 4 or n != 5 or n != 8){
+                    //     Scierror(999, "Incorrect dimension of matrix for argument. Only size of 4, 5, or 8 required\n"); 
+                    //     return 0; 
+                    // }
+
+                    distCoeffs = (double*)malloc(sizeof(double) * n);
+
+                    for(i = 0; i < n; ++i){
+                      distCoeffs[i] = pdblReal[i]; 
+                    }
+                    
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[0] = 1;
+                }
+                // Send an error message if an argument is provided more than once. Same for all optional arguments.
+
+                else if(providedArgs[0]){
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+
+                // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+
+                else {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+        }
+
+        else if(strcmp(currentArg, "newCameraMatrix") == 0){
+
+          if(iter+1 <= nbInputArguments and !providedArgs[1]){
+                    
+                    sciErr = getVarAddressFromPosition(pvApiCtx, ++iter, &piAddr4); 
+                    
+                    if (sciErr.iErr){
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+                    
+                    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows1, &iCols1, &newCameraMatrix); 
+                    
+                    if(sciErr.iErr){
+                        printError(&sciErr, 0); 
+                        return 0; 
+                    }
+
+                    if(iRows1 !=3 and iCols1 != 3){
+                      Scierror(999, "Incorrect dimension of matrix for argument\n"); 
+                      return 0; 
+                    }
+          
+                    // Checking if values are in proper range. Same for all optional arguments
+                    providedArgs[1] = 1;
+                }
+                // Send an error message if an argument is provided more than once. Same for all optional arguments.
+
+                else if(providedArgs[1]){
+                    Scierror(999, "Please provide optional arguments only once.\n"); 
+                    return 0; 
+                }
+
+                // Send an error message if name of argument is given but type is incorrect. Same for all optional arguments.
+
+                else {
+                    Scierror(999, "Incorrect number of arguments provided. Please check the documentation for more information.\n"); 
+                    return 0; 
+                }
+        }
+        else{
+          sciprint("Invalid argument provided; Using defalult values\n");
+        }
+
+    }
+
+    Mat _distCoeffs = Mat::zeros(1, n, CV_64F);
+
+    /// if distCoeffs was provided else it will be NULL / empty
+    if(providedArgs[0]){
+      for(i = 0; i < n; ++i)
+        _distCoeffs.at<double>(0, i) = distCoeffs[i];
+    }
+
+    /// By default the _newCameraMatrix has the same value of CameraMatrix
+    Mat _newCameraMatrix(3, 3, CV_64F, &cameraMatrix);
+
+    if(providedArgs[1]){
+      for(i = 0; i < 3; ++i)
+        for(j = 0; j < 3; ++j)
+          _newCameraMatrix.at<double>(i, j) = newCameraMatrix[j * 3 + i];
+    }
+
+    Mat new_image;
+    undistort(image, new_image, _cameraMatrix, _distCoeffs, _newCameraMatrix);
+
+
+    string tempstring = type2str(new_image.type());
+    char *checker;
+    checker = (char *)malloc(tempstring.size() + 1);
+    memcpy(checker, tempstring.c_str(), tempstring.size() + 1);
+    returnImage(checker, new_image, 1);
+    free(checker);
+
+
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
diff --git a/sci_gateway1/cpp/opencv_undistortPoints.cpp b/sci_gateway1/cpp/opencv_undistortPoints.cpp
new file mode 100644
index 0000000..dff80e4
--- /dev/null
+++ b/sci_gateway1/cpp/opencv_undistortPoints.cpp
@@ -0,0 +1,190 @@
+/***************************************************
+Author : Deepshikha
+***************************************************/
+
+#include <numeric>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/opencv.hpp"
+#include <iostream>
+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"
+  
+  int opencv_undistortPoints(char *fname, unsigned long fname_len)
+  {
+    //variables
+    int i,j,k,n,m;
+    int iRows=0,iCols=0;
+    int *piAddr1  = NULL;
+    int *piAddr2  = NULL;
+    int *piAddr3  = NULL;
+    int *piAddr4  = NULL;
+    int *piAddr5  = NULL;
+    
+    double *pdblReal = NULL;
+
+    SciErr sciErr;
+
+    //function varible
+    std::vector< Point2d > Src;
+    std::vector< Point2d > dst;
+    double cameraMatrix [3][3];
+    double newCameraMatrix [3][3];
+    double *distCoeffs = NULL;
+    double RectificationMatrix[3][3];
+
+    /*------------------------------------------- Checking Input Argument ----------------------------------------------------*/
+    
+    CheckInputArgument(pvApiCtx, 5, 5);
+    CheckOutputArgument(pvApiCtx, 1, 1) ;
+
+    /*------------------------------------- Source matrix :- First argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    // For 1 X N single channel
+    for(i = 0; i < iRows; ++i)
+            Src.push_back( Point2d(pdblReal[(0 * iRows) + i], pdblReal[(1 * iRows) + i]));
+
+    /* ------------------------------------ Camera matrix :- Second argument of the input -------------------------------------*/
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    Mat cameraMat(3, 3, CV_64F);
+    for(i=0;i<3;i++)
+        for(j=0;j<3;j++)
+            cameraMat.at<double>(i,j) = pdblReal[(j * 3) + i];
+    
+
+    /* ------------------------------------ Distortion Coefficient matrix :- Third argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx,3,&piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+
+    if(iRows== 1)
+        n = iCols;
+    else if (iCols == 1)
+        n = iRows;
+    else{
+        Scierror(1,"Points matrix (arg 4) must be a 2 X N matrix");
+        return 0;
+    }
+    if(n==4 or n==5 or n==8);
+    else{
+        Scierror(1," n must be 4 or 5 or 8");
+        return 0;
+    }
+
+    Mat distCoeffsActual(1,n,CV_64F);
+    for(i=0;i<n;i++)
+        distCoeffsActual.at<double>(0,i) = pdblReal[i];
+
+
+    /* ------------------------------------ Rectification matrix :- Fourth argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &iRows, &iCols, &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    Mat RectMat(3, 3, CV_64F);
+    for(i=0;i<3;i++)
+        for(j=0;j<3;j++)
+            RectMat.at<double>(i,j) =pdblReal[(j*3)+i];
+    
+
+    /* ------------------------------------ New Camera matrix :- Fifth argument of the input -------------------------------------*/
+    
+    sciErr = getVarAddressFromPosition(pvApiCtx,5,&piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr5, &iRows, &iCols , &pdblReal);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 0;
+    } 
+
+    Mat newCameraMat(3,3,CV_64F);
+    for(i=0;i<3;i++)
+        for(j=0;j<3;j++)
+            newCameraMat.at<double>(i, j) =pdblReal[(j*3)+i];  
+
+    
+    
+    /* opencv function for undistortPoints */
+    undistortPoints(Src, dst, cameraMat, distCoeffsActual, RectMat, newCameraMat);
+
+    /* Writing to Scilab */
+    double *pstdata = NULL;
+    pstdata = (double*)malloc(sizeof(double) * dst.size() * 2);
+    
+    for(i = 0; i < dst.size(); i++)
+    {
+            pstdata[i + 0 * dst.size()] = dst[i].x;
+            pstdata[i + 1 * dst.size()] = dst[i].y;
+    }
+
+    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dst.size(), 2, pstdata);
+    if(sciErr.iErr){
+      printError(&sciErr, 0);
+      return 0;
+    }
+    
+    //Assigning the list as the Output Variable
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    //Returning the Output Variables as arguments to the Scilab environment
+    ReturnArguments(pvApiCtx);
+    return 0;
+
+  }
+/* ==================================================================== */
+}
\ No newline at end of file
diff --git a/sci_gateway1/cpp/rotationMatrixToVector.cpp b/sci_gateway1/cpp/rotationMatrixToVector.cpp
new file mode 100644
index 0000000..40ef093
--- /dev/null
+++ b/sci_gateway1/cpp/rotationMatrixToVector.cpp
@@ -0,0 +1,139 @@
+/***************************************************
+Author : Shashank Shekhar
+**************************************************/
+
+#include <bits/stdc++.h>
+using namespace std;
+extern "C"
+{
+    #include "api_scilab.h"
+    #include "Scierror.h"
+    #include "BOOL.h"
+    #include <localization.h>
+    #include "sciprint.h"
+
+	int rotationMTV(char *fname, unsigned long fname_len)
+	{
+		SciErr sciErr;
+		int *piAddr = NULL;
+		int iRows = 0;
+        int iCols = 0;
+		int *piLen = 0;
+		char **pstData = NULL;
+		double RotMat[9];
+        double *temp = NULL;
+    	int noOfarguments = *getNbInputArgument(pvApiCtx);
+        double outMat[3];
+        double theta;
+    	int i;
+
+
+
+	    CheckInputArgument(pvApiCtx,1,1);
+	    CheckOutputArgument(pvApiCtx,1,1);	
+
+    	sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
+        if (sciErr.iErr)
+        {
+            printError(&scisErr, 0);
+            return 0;
+        }
+
+        if(!isDoubleType(pvApiCtx, piAddr) || isVarComplex(pvApiCtx, piAddr))
+        {
+            Scierror(999,"A 3x3 Matrix expected.\n");
+            return 0;
+        }
+
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &temp);  
+        if(sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 0;
+        }
+
+        if(iRows!=3 || iCols!=3)
+        {
+            Scierror(999,"Invalid Argument\n");
+            return 0;
+        }
+          
+        for(i=0;i<3;i++)
+        {
+            for(int j=0;j<3;j++)
+            {
+                RotMat[j*3+i]=temp[i*3+j];    
+            }
+        }
+
+//  -----------------------------------------------------------  Evaluation  --------------------------------------------------------
+
+        double myMat[3][3];
+        for(int i=0;i<3;i++)
+            for(int j=0;j<3;j++)
+                myMat[i][j] = RotMat[i*3+j];
+       
+        double trace = RotMat[0]+RotMat[4]+RotMat[8];
+        theta = acos((trace-1)/2);       
+        outMat[0] = myMat[2][1]-myMat[1][2];
+        outMat[1] = myMat[0][2]-myMat[2][0];
+        outMat[2] = myMat[1][0]-myMat[0][1];
+
+        double element;
+        double threshold = 1e-4;
+        if(sin(theta) >= threshold)
+        {
+            element = theta/(2*sin(theta));           
+            for(int i=0;i<3;i++)
+                outMat[i]=outMat[i]*element;          
+        }
+        else if (theta-1 > 0)
+        {
+            element = (0.5-(theta-3)/12);
+            for(int i=0;i<3;i++)
+                outMat[i]=outMat[i]*element;
+        }
+        else
+        {
+            double myMax=myMat[0][0];
+            int iter1=0;
+            int iter2,iter3;
+            for(int i=0;i<3;i++)
+            {
+                if(myMat[i][i]>myMax)
+                {
+                    myMax=myMat[i][i];
+                    iter1=i;
+                }
+            }
+
+            iter2 = (iter1%2) +1;
+            iter3 = ((iter1+1)%2) +1;
+
+            double ev = sqrt(myMat[iter1][iter1] - myMat[iter2][iter2] - myMat[iter3][iter3] + 1);
+            outMat[0] = ev/2;
+            outMat[1] = (myMat[iter2][iter1] + myMat[iter1][iter2])/(2*ev);
+            outMat[2] = (myMat[iter3][iter1] + myMat[iter1][iter3])/(2*ev);
+
+            for(int i=0;i<3;i++)
+                ev+=pow(outMat[i],2);
+            ev = sqrt(ev);
+
+            for(int i=0;i<3;i++)
+                outMat[i]=(outMat[i]/ev)*theta;
+        }
+
+//		--------------------------------------------------------Creating 1x3 Mat to Return -------------------------------------------------------------
+
+	    sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 3,1,outMat);
+	    if(sciErr.iErr)
+	    {
+	        printError(&sciErr, 0);
+	        return 0;
+	    }
+
+	    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+	    ReturnArguments(pvApiCtx);
+	    return 0;
+    }
+}
\ No newline at end of file
diff --git a/sci_gateway1/loader_gateway.sce b/sci_gateway1/loader_gateway.sce
new file mode 100644
index 0000000..6809d99
--- /dev/null
+++ b/sci_gateway1/loader_gateway.sce
@@ -0,0 +1,24 @@
+// This file is released under the 3-clause BSD license. See COPYING-BSD.
+// Generated by builder_gateway.sce: Please, do not edit this file
+
+try
+    v = getversion("scilab");
+catch
+    v = [ 5 0 ]; // or older 
+end
+if (v(1) <= 5) & (v(2) < 3) then
+    // new API in scilab 5.3
+    error(gettext("Scilab 5.3 or more is required."));
+end
+
+sci_gateway_dir = get_absolute_file_path("loader_gateway.sce");
+current_dir     = pwd();
+
+chdir(sci_gateway_dir);
+if ( isdir("cpp") ) then
+    chdir("cpp");
+    exec("loader.sce");
+end
+
+chdir(current_dir);
+clear sci_gateway_dir current_dir v;