diff options
Diffstat (limited to 'src/c')
16 files changed, 666 insertions, 8 deletions
diff --git a/src/c/hardware/rasberrypi/includes/RPIPeripheralThreading.h b/src/c/hardware/rasberrypi/includes/RPIPeripheralThreading.h index 2304567..a7b2adb 100644 --- a/src/c/hardware/rasberrypi/includes/RPIPeripheralThreading.h +++ b/src/c/hardware/rasberrypi/includes/RPIPeripheralThreading.h @@ -19,7 +19,7 @@ extern "C" { #endif -uint16 RPIThreadCreate(void *(*threadFunction)(void)); +uint16 RPIThreadCreate(void *(*threadFunction)(void*)); #ifdef __cplusplus } /* extern "C" */ diff --git a/src/c/hardware/rasberrypi/threading/u16RPIThreadCreates.c b/src/c/hardware/rasberrypi/threading/u16RPIThreadCreates.c index d0a063a..c05c959 100644 --- a/src/c/hardware/rasberrypi/threading/u16RPIThreadCreates.c +++ b/src/c/hardware/rasberrypi/threading/u16RPIThreadCreates.c @@ -15,7 +15,7 @@ #include "types.h" #include "RPIPeripheralThreading.h" -uint16 RPIThreadCreate(void *(*threadFunction)(void)) +uint16 RPIThreadCreate(void *(*threadFunction)(void*)) { int status; status = piThreadCreate (threadFunction); diff --git a/src/c/imageProcessing/cvimgproc/imcvAdaptThresholds.cpp b/src/c/imageProcessing/cvimgproc/imcvAdaptThresholds.cpp new file mode 100644 index 0000000..927cfb3 --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvAdaptThresholds.cpp @@ -0,0 +1,47 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvAdaptThresholds(Mat src, double t_value, double maxvalue, char* AdaptiveMethod, \ + char* ThreholdType, double blocksize, double cont) +{ + + Mat dst(src.rows, src.cols, src.type()); + + if(strcmp(AdaptiveMethod,"ADAPTIVE_THRESH_MEAN_C") == 0) + { + if(strcmp(ThreholdType, "THRESH_BINARY") == 0) + adaptiveThreshold(src,dst,maxvalue,ADAPTIVE_THRESH_MEAN_C, \ + THRESH_BINARY,blocksize,cont); + else if(strcmp(ThreholdType, "THRESH_BINARY_INV") == 0) + adaptiveThreshold(src,dst,maxvalue,ADAPTIVE_THRESH_MEAN_C, \ + THRESH_BINARY_INV,blocksize,cont); + } + else if(strcmp(AdaptiveMethod,"ADAPTIVE_THRESH_GAUSSIAN_C") == 0) + { + if(strcmp(ThreholdType, "THRESH_BINARY") == 0) + adaptiveThreshold(src,dst,maxvalue,ADAPTIVE_THRESH_GAUSSIAN_C, \ + THRESH_BINARY,blocksize,cont); + else if(strcmp(ThreholdType, "THRESH_BINARY_INV") == 0) + adaptiveThreshold(src,dst,maxvalue,ADAPTIVE_THRESH_GAUSSIAN_C, \ + THRESH_BINARY_INV,blocksize,cont); + } + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvBlurs.cpp b/src/c/imageProcessing/cvimgproc/imcvBlurs.cpp new file mode 100644 index 0000000..d5c06de --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvBlurs.cpp @@ -0,0 +1,55 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvBlurs(Mat src, double ksize_width, double ksize_height, double anchor_x, \ + double anchor_y, char* border_type) +{ + + /*Mat dst(src.rows, src.cols, src.type());*/ + Mat dst = src.clone(); + + Point anchor = Point(anchor_x,anchor_y); + Size2f ksize = Size2f(ksize_width, ksize_height); + + if(strcmp(border_type,"BORDER_REPLICATE") == 0) + { + blur(src,dst,ksize,anchor,BORDER_REPLICATE); + } + else if(strcmp(border_type,"BORDER_REFLECT")) + { + blur(src,dst,ksize,anchor,BORDER_REFLECT); + } + else if(strcmp(border_type,"BORDER_REFLECT_101")) + { + blur(src,dst,ksize,anchor,BORDER_REFLECT_101); + } + else if(strcmp(border_type,"BORDER_WRAP")) + { + blur(src,dst,ksize,anchor,BORDER_WRAP); + } + else if(strcmp(border_type,"BORDER_CONSTANT")) + { + blur(src,dst,ksize,anchor,BORDER_CONSTANT); + } + + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvCanny.cpp b/src/c/imageProcessing/cvimgproc/imcvCanny.cpp new file mode 100644 index 0000000..a81450b --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvCanny.cpp @@ -0,0 +1,31 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to find edges in image */ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvCanny(Mat src, double threshold1, double threshold2, double \ + aperture_size, double L2gradient) +{ + + Mat dst = src.clone(); + + Canny(src, dst, threshold1, threshold2, aperture_size, L2gradient); + + return dst; +} diff --git a/src/c/imageProcessing/cvimgproc/imcvCornerHarris.cpp b/src/c/imageProcessing/cvimgproc/imcvCornerHarris.cpp new file mode 100644 index 0000000..d6df1cc --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvCornerHarris.cpp @@ -0,0 +1,55 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to find edges using Harris algorithm*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvCornerHarris(Mat src, double blocksize, double ksize, double k, \ + char* border_type) +{ + + Mat dst(src.rows, src.cols, CV_32FC1); + + if(strcmp(border_type,"BORDER_REPLICATE") == 0) + { + cornerHarris(src,dst,blocksize,ksize,k,BORDER_REPLICATE); + } + else if(strcmp(border_type,"BORDER_REFLECT")) + { + cornerHarris(src,dst,blocksize,ksize,k,BORDER_REFLECT); + } + else if(strcmp(border_type,"BORDER_REFLECT_101")) + { + cornerHarris(src,dst,blocksize,ksize,k,BORDER_REFLECT_101); + } + else if(strcmp(border_type,"BORDER_WRAP")) + { + cornerHarris(src,dst,blocksize,ksize,k,BORDER_WRAP); + } + else if(strcmp(border_type,"BORDER_CONSTANT")) + { + cornerHarris(src,dst,blocksize,ksize,k,BORDER_CONSTANT); + } + else if(strcmp(border_type,"BORDER_DEFAULT")) + { + cornerHarris(src,dst,blocksize,ksize,k,BORDER_DEFAULT); + } + + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvCvtColors.cpp b/src/c/imageProcessing/cvimgproc/imcvCvtColors.cpp index 1523afe..eaad278 100644 --- a/src/c/imageProcessing/cvimgproc/imcvCvtColors.cpp +++ b/src/c/imageProcessing/cvimgproc/imcvCvtColors.cpp @@ -22,8 +22,127 @@ using namespace cv; Mat imcvCvtColors(Mat src, char* code) { Mat dst(src.rows, src.cols, src.type()); + + /*RGB <--> Gray*/ if(strcmp(code,"CV_RGB2GRAY") == 0) - cvtColor(src,dst,CV_RGB2GRAY); + {cvtColor(src,dst,CV_RGB2GRAY);} + else if(strcmp(code,"CV_BGR2GRAY") == 0) + {cvtColor(src,dst,CV_BGR2GRAY);} + else if(strcmp(code,"CV_GRAY2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_GRAY2RGB);} + else if(strcmp(code,"CV_GRAY2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_GRAY2BGR);} + + /*RGB <--> CIE XYZ.Rec 709 with D65 white point*/ + else if(strcmp(code,"CV_RGB2XYZ") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_RGB2XYZ);} + else if(strcmp(code,"CV_BGR2XYZ") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BGR2XYZ);} + else if(strcmp(code,"CV_XYZ2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_XYZ2RGB);} + else if(strcmp(code,"CV_XYZ2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_XYZ2BGR);} + + /*RGB <--> YCrCb JPEG (or YCC) */ + else if(strcmp(code,"CV_BGR2YCrCb") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BGR2YCrCb);} + else if(strcmp(code,"CV_RGB2YCrCb") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_RGB2YCrCb);} + else if(strcmp(code,"CV_YCrCb2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_YCrCb2BGR);} + else if(strcmp(code,"CV_YCrCb2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_YCrCb2RGB);} + + /*RGB <--> HSV */ + else if(strcmp(code,"CV_BGR2HSV") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BGR2HSV);} + else if(strcmp(code,"CV_RGB2HSV") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_RGB2HSV);} + else if(strcmp(code,"CV_HSV2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_HSV2BGR);} + else if(strcmp(code,"CV_HSV2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_HSV2RGB);} + + /*RGB <--> HLS */ + else if(strcmp(code,"CV_BGR2HLS") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BGR2HLS);} + else if(strcmp(code,"CV_RGB2HLS") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_RGB2HLS);} + else if(strcmp(code,"CV_HLS2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_HLS2BGR);} + else if(strcmp(code,"CV_HLS2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_HLS2RGB);} + /*RGB <--> CIE L*a*b* */ + else if(strcmp(code,"CV_BGR2Lab") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BGR2Lab);} + else if(strcmp(code,"CV_RGB2Lab") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_RGB2Lab);} + else if(strcmp(code,"CV_Lab2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_Lab2BGR);} + else if(strcmp(code,"CV_Lab2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_Lab2RGB);} + + /*RGB <--> CIE L*u*v* */ + else if(strcmp(code,"CV_BGR2Luv") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BGR2Luv);} + else if(strcmp(code,"CV_RGB2Luv") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_RGB2Luv);} + else if(strcmp(code,"CV_Luv2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_Luv2BGR);} + else if(strcmp(code,"CV_Luv2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_Luv2RGB);} + + /*Bayer <--> RGB */ + else if(strcmp(code,"CV_BayerBG2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerBG2BGR);} + else if(strcmp(code,"CV_BayerGB2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerGB2BGR);} + else if(strcmp(code,"CV_BayerRG2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerRG2BGR);} + else if(strcmp(code,"CV_BayerGR2BGR") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerGR2BGR);} + else if(strcmp(code,"CV_BayerBG2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerBG2RGB);} + else if(strcmp(code,"CV_BayerGB2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerGB2RGB);} + else if(strcmp(code,"CV_BayerRG2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerRG2RGB);} + else if(strcmp(code,"CV_BayerBG2RGB") == 0) + {dst.reshape(3); + cvtColor(src,dst,CV_BayerGR2RGB);} return dst; -}
\ No newline at end of file +} diff --git a/src/c/imageProcessing/cvimgproc/imcvDilate.cpp b/src/c/imageProcessing/cvimgproc/imcvDilate.cpp new file mode 100644 index 0000000..1659cf5 --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvDilate.cpp @@ -0,0 +1,71 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvDilate(Mat src, char* dilation_type, double size, double iterations, \ + char* border_type, double border_value) +{ + + /*Mat dst(src.rows, src.cols, src.type());*/ + Mat dst = src.clone(); + int dilate_type =0; + + if(strcmp(dilation_type,"MORPH_RECT") == 0) + { + dilate_type = MORPH_RECT; + } + else if(strcmp(dilation_type,"MORPH_CROSS") == 0) + { + dilate_type = MORPH_CROSS; + } + else if(strcmp(dilation_type,"MORPH_ELLIPSE") == 0) + { + dilate_type = MORPH_ELLIPSE; + } + + + Mat element = getStructuringElement(dilate_type, Size(size,size), \ + Point((size-1)/2,(size-1)/2)); + + if(strcmp(border_type,"BORDER_REPLICATE") == 0) + { + dilate(src, dst, element, Point(-1,-1), iterations, BORDER_REPLICATE); + } + else if(strcmp(border_type,"BORDER_REFLECT")) + { + dilate(src, dst, element, Point(-1,-1), iterations, BORDER_REFLECT); + } + else if(strcmp(border_type,"BORDER_REFLECT_101")) + { + dilate(src, dst, element, Point(-1,-1), iterations,BORDER_REFLECT_101); + } + else if(strcmp(border_type,"BORDER_WRAP")) + { + dilate(src, dst, element, Point(-1,-1), iterations, BORDER_WRAP); + } + else if(strcmp(border_type,"BORDER_CONSTANT")) + { + dilate(src, dst, element, Point(-1,-1), iterations, BORDER_CONSTANT, \ + Scalar(border_value)); + } + + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvDistanceTransforms.cpp b/src/c/imageProcessing/cvimgproc/imcvDistanceTransforms.cpp new file mode 100644 index 0000000..e53292a --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvDistanceTransforms.cpp @@ -0,0 +1,41 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvDistanceTransforms(Mat src, char* distance_type, int mask_size ) +{ + + Mat dst(src.rows, src.cols, CV_32F); + + if(strcmp(distance_type,"CV_DIST_L1") == 0) + { + distanceTransform(src,dst,CV_DIST_L1,mask_size); + } + else if(strcmp(distance_type,"CV_DIST_L2") == 0) + { + distanceTransform(src,dst,CV_DIST_L2,mask_size); + } + else if(strcmp(distance_type,"CV_DIST_C") == 0) + { + distanceTransform(src,dst,CV_DIST_C,mask_size); + } + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvErode.cpp b/src/c/imageProcessing/cvimgproc/imcvErode.cpp new file mode 100644 index 0000000..64bae01 --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvErode.cpp @@ -0,0 +1,71 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvErode(Mat src, char* erosion_type, double size, double iterations, \ + char* border_type, double border_value) +{ + + /*Mat dst(src.rows, src.cols, src.type());*/ + Mat dst = src.clone(); + int erode_type =0; + + if(strcmp(erosion_type,"MORPH_RECT") == 0) + { + erode_type = MORPH_RECT; + } + else if(strcmp(erosion_type,"MORPH_CROSS") == 0) + { + erode_type = MORPH_CROSS; + } + else if(strcmp(erosion_type,"MORPH_ELLIPSE") == 0) + { + erode_type = MORPH_ELLIPSE; + } + + + Mat element = getStructuringElement(erode_type, Size(size,size), \ + Point((size-1)/2,(size-1)/2)); + + if(strcmp(border_type,"BORDER_REPLICATE") == 0) + { + erode(src, dst, element, Point(-1,-1), iterations, BORDER_REPLICATE); + } + else if(strcmp(border_type,"BORDER_REFLECT")) + { + erode(src, dst, element, Point(-1,-1), iterations, BORDER_REFLECT); + } + else if(strcmp(border_type,"BORDER_REFLECT_101")) + { + erode(src, dst, element, Point(-1,-1), iterations, BORDER_REFLECT_101); + } + else if(strcmp(border_type,"BORDER_WRAP")) + { + erode(src, dst, element, Point(-1,-1), iterations, BORDER_WRAP); + } + else if(strcmp(border_type,"BORDER_CONSTANT")) + { + erode(src, dst, element, Point(-1,-1), iterations, BORDER_CONSTANT, \ + Scalar(border_value)); + } + + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvGaussianBlurs.cpp b/src/c/imageProcessing/cvimgproc/imcvGaussianBlurs.cpp new file mode 100644 index 0000000..3c8c481 --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvGaussianBlurs.cpp @@ -0,0 +1,54 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvGaussianBlurs(Mat src, double ksize_width, double ksize_height, + double sigma_x, double sigma_y, char* border_type) +{ + + /*Mat dst(src.rows, src.cols, src.type());*/ + Mat dst = src.clone(); + + Size2f ksize = Size2f(ksize_width, ksize_height); + + if(strcmp(border_type,"BORDER_REPLICATE") == 0) + { + GaussianBlur(src,dst,ksize,sigma_x,sigma_y,BORDER_REPLICATE); + } + else if(strcmp(border_type,"BORDER_REFLECT")) + { + GaussianBlur(src,dst,ksize,sigma_x,sigma_y,BORDER_REFLECT); + } + else if(strcmp(border_type,"BORDER_REFLECT_101")) + { + GaussianBlur(src,dst,ksize,sigma_x,sigma_y,BORDER_REFLECT_101); + } + else if(strcmp(border_type,"BORDER_WRAP")) + { + GaussianBlur(src,dst,ksize,sigma_x,sigma_y,BORDER_WRAP); + } + else if(strcmp(border_type,"BORDER_CONSTANT")) + { + GaussianBlur(src,dst,ksize,sigma_x,sigma_y,BORDER_CONSTANT); + } + + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvMedianBlurs.cpp b/src/c/imageProcessing/cvimgproc/imcvMedianBlurs.cpp new file mode 100644 index 0000000..d8e90ff --- /dev/null +++ b/src/c/imageProcessing/cvimgproc/imcvMedianBlurs.cpp @@ -0,0 +1,31 @@ +/* Copyright (C) 2016 - IIT Bombay - FOSSEE + + This file must be used under the terms of the CeCILL. + This source file is licensed as described in the file COPYING, which + you should have received as part of this distribution. The terms + are also available at + http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + Author: Siddhesh Wani + Organization: FOSSEE, IIT Bombay + Email: toolbox@scilab.in +*/ + +/* Function to adaptive threshold a gray scale image*/ + +#include "types.h" +#include "cvcore.hpp" +#include "cvimgproc.hpp" + + +using namespace cv; + +Mat imcvMedianBlurs(Mat src, double ksize) +{ + + /*Mat dst(src.rows, src.cols, src.type());*/ + Mat dst = src.clone(); + + medianBlur(src,dst,(int)ksize); + + return dst; +}
\ No newline at end of file diff --git a/src/c/imageProcessing/cvimgproc/imcvThresholds.cpp b/src/c/imageProcessing/cvimgproc/imcvThresholds.cpp index 2e40de9..9664a44 100644 --- a/src/c/imageProcessing/cvimgproc/imcvThresholds.cpp +++ b/src/c/imageProcessing/cvimgproc/imcvThresholds.cpp @@ -22,8 +22,17 @@ using namespace cv; Mat imcvThresholds(Mat src, double t_value, double maxvalue, char* type) { Mat dst(src.rows, src.cols, src.type()); + if(strcmp(type,"THRESH_BINARY") == 0) threshold(src,dst,t_value,maxvalue,THRESH_BINARY); + if(strcmp(type,"THRESH_BINARY_INV") == 0) + threshold(src,dst,t_value,maxvalue,THRESH_BINARY_INV); + if(strcmp(type,"THRESH_TRUNC") == 0) + threshold(src,dst,t_value,maxvalue,THRESH_TRUNC); + if(strcmp(type,"THRESH_TOZERO") == 0) + threshold(src,dst,t_value,maxvalue,THRESH_TOZERO); + if(strcmp(type,"THRESH_TOZERO_INV") == 0) + threshold(src,dst,t_value,maxvalue,THRESH_TOZERO_INV); return dst; }
\ No newline at end of file diff --git a/src/c/imageProcessing/includes/cvimgproc.hpp b/src/c/imageProcessing/includes/cvimgproc.hpp index b7d2faa..8fdf3e3 100644 --- a/src/c/imageProcessing/includes/cvimgproc.hpp +++ b/src/c/imageProcessing/includes/cvimgproc.hpp @@ -20,6 +20,33 @@ using namespace cv; Mat imcvCvtColors(Mat src, char* code); + Mat imcvThresholds(Mat src, double threshold, double maxvalue, char* type); +Mat imcvAdaptThresholds(Mat src, double t_value, double maxvalue, char* AdaptiveMethod, \ + char* ThreholdType, double blocksize, double C); + +Mat imcvDistanceTransforms(Mat src, char* distance_type, int mask_size); + + +Mat imcvBlurs(Mat src, double ksize_width, double ksize_height, double anchor_x, \ + double anchor_y, char* border_type); + +Mat imcvGaussianBlurs(Mat src, double ksize_width, double ksize_height, double sigma_x, \ + double sigma_y, char* border_type); + +Mat imcvMedianBlurs(Mat src, double ksize); + +Mat imcvErode(Mat src, char* erosion_type, double size, double iterations, \ + char* border_type, double border_value); + +Mat imcvDilate(Mat src, char* dilation_type, double size, double iterations, \ + char* border_type, double border_value); + +Mat imcvCanny(Mat src, double threshold1, double threshold2, double \ + aperture_size, double L2gradient); + +Mat imcvCornerHarris(Mat src, double blocksize, double ksize, double k, \ + char* border_type); + #endif /*__CVIMGPROC_H__*/ diff --git a/src/c/imageProcessing/interfaces/int_cvhighgui.hpp b/src/c/imageProcessing/interfaces/int_cvhighgui.hpp index 05f260f..8e1a989 100644 --- a/src/c/imageProcessing/interfaces/int_cvhighgui.hpp +++ b/src/c/imageProcessing/interfaces/int_cvhighgui.hpp @@ -20,8 +20,8 @@ //#define g2d0CV_LoadImageim0(filename,name_size,loadtype) imcvLoadImages(filename,loadtype) #define g2d0CV_LoadImagemt0(filename,name_size,loadtype) imread(filename,loadtype) -#define g2mt0CV_ShowImageu80(winname,win_size,img) imshow(winname,img) -#define mt0CV_ShowImageu80(img) imshow("",img) +#define g2mt0CV_ShowImageu80(winname,win_size,img) imcvShowImages(winname,img) +#define mt0CV_ShowImageu80(img) imcvShowImages("",img) #define d0CV_WaitKeyu80(delay) cvWaitKey(delay) #define g2mt0CV_SaveImageu80(filename,name_size,img) imwrite(filename,img) diff --git a/src/c/imageProcessing/interfaces/int_cvimgproc.hpp b/src/c/imageProcessing/interfaces/int_cvimgproc.hpp index 65fa77e..9b1a85c 100644 --- a/src/c/imageProcessing/interfaces/int_cvimgproc.hpp +++ b/src/c/imageProcessing/interfaces/int_cvimgproc.hpp @@ -18,7 +18,54 @@ #include "opencv2/imgproc/imgproc.hpp" #define mt0g2CV_CvtColormt0(src,code,code_size) imcvCvtColors(src,code) -#define mt0d0d0g2CV_Thresholdmt0(src,threshold,maxvalue,thresh_type,type_size) \ - imcvThresholds(src,threshold,maxvalue,thresh_type) + +#define mt0d0d0g2CV_Thresholdmt0(src,threshold,maxvalue,thresh_type, \ + type_size) imcvThresholds(src,threshold,maxvalue,thresh_type) + +#define mt0d0g2g2d0d0CV_AdaptiveThresholdmt0(src,maxvalue,adaptmethod, \ + adapt_size,thresh_type,blocksize,C) imcvAdaaptThresholds(src, \ + maxvalue,adaptmethod,thresh_type,blocksize,C) + +#define mt0g2d0CV_DistanceTransform(src,distance_type,type_size,mask_size) \ + imcvDistanceTransform(src,distance_type,mask_size) + +#define mt0d0d0d0d0g2CV_Blurmt0(src,ksize_width,ksize_height,anchor_x, \ + anchor_y,border_type,type_size) imcvBlurs(src,ksize_width, \ + ksize_height,anchor_x,anchor_y,border_type) + +#define mt0d0d0d0d0g2CV_GaussianBlurmt0(src,ksize_width,ksize_height,sigma_x, \ + sigma_y,border_type,type_size) imcvGaussianBlurs(src,ksize_width, \ + ksize_height,sigma_x,sigma_y,border_type) + +#define mt0d0CV_MedianBlurmt0(src,ksize) imcvMedianBlurs(src,ksize) + +#define mt0g2d0CV_Erodemt0(src,erosion_type,type_size,erosion_size) \ + imcvErode(src,erosion_type,erosion_size,1,"BORDER_CONSTANT",0) + +#define mt0g2d0d0g2d0CV_Erodemt0(src,erosion_type,type_size,erosion_size, \ + iterations,border_type,bor_size,border_value) \ + imcvErode(src,erosion_type,erosion_size,iterations,border_type, \ + border_value) + +#define mt0g2d0CV_Dilatemt0(src,dilation_type,type_size,dilation_size) \ + imcvDilate(src,dilation_type,dilation_size,1,"BORDER_CONSTANT",0) + +#define mt0g2d0d0g2d0CV_Dilatemt0(src,dilation_type,type_size,dilation_size, \ + iterations,border_type,bor_size,border_value) \ + imcvDilate(src,dilation_type,dilation_size,iterations,border_type, \ + border_value) + +#define mt0d0d0d0d0CV_Cannymt0(src,threshold1,threshold2,aperture_size, \ + L2gradient) imcvCanny(src,threshold1,threshold2,aperture_size, \ + L2gradient) + +#define mt0d0d0CV_Cannymt0(src,threshold1,threshold2) imcvCanny(src, \ + threshold1,threshold2,3,0) + +#define mt0d0d0d0g2CV_CornerHarrismt0(src,blocksize,ksize,k,border_type, \ + type_size) imcvCornerHarris(src,blocksize,ksize,k,border_type) + +#define mt0d0d0d0CV_CornerHarrismt0(src,blocksize,ksize,k) \ + imcvCornerHarris(src,blocksize,ksize,k,"BORDER_DEFAULT") #endif /*__INT_CVIMGPROC_H__*/ |