First CommitHEADmaster

3 files changed, 1125 insertions, 0 deletions

diff --git a/thirdparty/linux/include/opencv2/stereo/descriptor.hpp b/thirdparty/linux/include/opencv2/stereo/descriptor.hpp
new file mode 100644
index 0000000..bdbd7ce
--- /dev/null
+++ b/thirdparty/linux/include/opencv2/stereo/descriptor.hpp
@@ -0,0 +1,452 @@
+//By downloading, copying, installing or using the software you agree to this license.
+//If you do not agree to this license, do not download, install,
+//copy or use the software.
+//
+//
+//                          License Agreement
+//               For Open Source Computer Vision Library
+//                       (3-clause BSD License)
+//
+//Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+//Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+//Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+//Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+//Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+//Copyright (C) 2015, Itseez Inc., all rights reserved.
+//Third party copyrights are property of their respective owners.
+//
+//Redistribution and use in source and binary forms, with or without modification,
+//are permitted provided that the following conditions are met:
+//
+//  * Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+//  * Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+//  * Neither the names of the copyright holders nor the names of the contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+//This software is provided by the copyright holders and contributors "as is" and
+//any express or implied warranties, including, but not limited to, the implied
+//warranties of merchantability and fitness for a particular purpose are disclaimed.
+//In no event shall copyright holders or contributors be liable for any direct,
+//indirect, incidental, special, exemplary, or consequential damages
+//(including, but not limited to, procurement of substitute goods or services;
+//loss of use, data, or profits; or business interruption) however caused
+//and on any theory of liability, whether in contract, strict liability,
+//or tort (including negligence or otherwise) arising in any way out of
+//the use of this software, even if advised of the possibility of such damage.
+
+/*****************************************************************************************************************\
+*   The interface contains the main descriptors that will be implemented in the descriptor class                  *
+\*****************************************************************************************************************/
+
+#include <stdint.h>
+#ifndef _OPENCV_DESCRIPTOR_HPP_
+#define _OPENCV_DESCRIPTOR_HPP_
+#ifdef __cplusplus
+
+namespace cv
+{
+    namespace stereo
+    {
+        //types of supported kernels
+        enum {
+            CV_DENSE_CENSUS, CV_SPARSE_CENSUS,
+            CV_CS_CENSUS, CV_MODIFIED_CS_CENSUS, CV_MODIFIED_CENSUS_TRANSFORM,
+            CV_MEAN_VARIATION, CV_STAR_KERNEL
+        };
+        //!Mean Variation is a robust kernel that compares a pixel
+        //!not just with the center but also with the mean of the window
+        template<int num_images>
+        struct MVKernel
+        {
+            uint8_t *image[num_images];
+            int *integralImage[num_images];
+            int stop;
+            MVKernel(){}
+            MVKernel(uint8_t **images, int **integral)
+            {
+                for(int i = 0; i < num_images; i++)
+                {
+                    image[i] = images[i];
+                    integralImage[i] = integral[i];
+                }
+                stop = num_images;
+            }
+            void operator()(int rrWidth,int w2, int rWidth, int jj, int j, int c[num_images]) const
+            {
+                (void)w2;
+                for (int i = 0; i < stop; i++)
+                {
+                    if (image[i][rrWidth + jj] > image[i][rWidth + j])
+                    {
+                        c[i] = c[i] + 1;
+                    }
+                    c[i] = c[i] << 1;
+                    if (integralImage[i][rrWidth + jj] > image[i][rWidth + j])
+                    {
+                        c[i] = c[i] + 1;
+                    }
+                    c[i] = c[i] << 1;
+                }
+            }
+        };
+        //!Compares pixels from a patch giving high weights to pixels in which
+        //!the intensity is higher. The other pixels receive a lower weight
+        template <int num_images>
+        struct MCTKernel
+        {
+            uint8_t *image[num_images];
+            int t,imageStop;
+            MCTKernel(){}
+            MCTKernel(uint8_t ** images, int threshold)
+            {
+                for(int i = 0; i < num_images; i++)
+                {
+                    image[i] = images[i];
+                }
+                imageStop = num_images;
+                t = threshold;
+            }
+            void operator()(int rrWidth,int w2, int rWidth, int jj, int j, int c[num_images]) const
+            {
+                (void)w2;
+                for(int i = 0; i < imageStop; i++)
+                {
+                    if (image[i][rrWidth + jj] > image[i][rWidth + j] - t)
+                    {
+                        c[i] = c[i] << 1;
+                        c[i] = c[i] + 1;
+                        c[i] = c[i] << 1;
+                        c[i] = c[i] + 1;
+                    }
+                    else if (image[i][rWidth + j] - t < image[i][rrWidth + jj] && image[i][rWidth + j] + t >= image[i][rrWidth + jj])
+                    {
+                        c[i] = c[i] << 2;
+                        c[i] = c[i] + 1;
+                    }
+                    else
+                    {
+                        c[i] <<= 2;
+                    }
+                }
+            }
+        };
+        //!A madified cs census that compares a pixel with the imediat neightbour starting
+        //!from the center
+        template<int num_images>
+        struct ModifiedCsCensus
+        {
+            uint8_t *image[num_images];
+            int n2;
+            int imageStop;
+            ModifiedCsCensus(){}
+            ModifiedCsCensus(uint8_t **images, int ker)
+            {
+                for(int i = 0; i < num_images; i++)
+                    image[i] = images[i];
+                imageStop = num_images;
+                n2 = ker;
+            }
+            void operator()(int rrWidth,int w2, int rWidth, int jj, int j, int c[num_images]) const
+            {
+                (void)j;
+                (void)rWidth;
+                for(int i = 0; i < imageStop; i++)
+                {
+                    if (image[i][(rrWidth + jj)] > image[i][(w2 + (jj + n2))])
+                    {
+                        c[i] = c[i] + 1;
+                    }
+                    c[i] = c[i] * 2;
+                }
+            }
+        };
+        //!A kernel in which a pixel is compared with the center of the window
+        template<int num_images>
+        struct CensusKernel
+        {
+            uint8_t *image[num_images];
+            int imageStop;
+            CensusKernel(){}
+            CensusKernel(uint8_t **images)
+            {
+                for(int i = 0; i < num_images; i++)
+                    image[i] = images[i];
+                imageStop = num_images;
+            }
+            void operator()(int rrWidth,int w2, int rWidth, int jj, int j, int c[num_images]) const
+            {
+                (void)w2;
+                for(int i = 0; i < imageStop; i++)
+                {
+                    ////compare a pixel with the center from the kernel
+                    if (image[i][rrWidth + jj] > image[i][rWidth + j])
+                    {
+                        c[i] += 1;
+                    }
+                    c[i] <<= 1;
+                }
+            }
+        };
+        //template clas which efficiently combines the descriptors
+        template <int step_start, int step_end, int step_inc,int nr_img, typename Kernel>
+        class CombinedDescriptor:public ParallelLoopBody
+        {
+        private:
+            int width, height,n2;
+            int stride_;
+            int *dst[nr_img];
+            Kernel kernel_;
+            int n2_stop;
+        public:
+            CombinedDescriptor(int w, int h,int stride, int k2, int **distance, Kernel kernel,int k2Stop)
+            {
+                width = w;
+                height = h;
+                n2 = k2;
+                stride_ = stride;
+                for(int i = 0; i < nr_img; i++)
+                    dst[i] = distance[i];
+                kernel_ = kernel;
+                n2_stop = k2Stop;
+            }
+            void operator()(const cv::Range &r) const {
+                for (int i = r.start; i <= r.end ; i++)
+                {
+                    int rWidth = i * stride_;
+                    for (int j = n2 + 2; j <= width - n2 - 2; j++)
+                    {
+                        int c[nr_img];
+                        memset(c,0,nr_img);
+                        for(int step = step_start; step <= step_end; step += step_inc)
+                        {
+                            for (int ii = - n2; ii <= + n2_stop; ii += step)
+                            {
+                                int rrWidth = (ii + i) * stride_;
+                                int rrWidthC = (ii + i + n2) * stride_;
+                                for (int jj = j - n2; jj <= j + n2; jj += step)
+                                {
+                                    if (ii != i || jj != j)
+                                    {
+                                        kernel_(rrWidth,rrWidthC, rWidth, jj, j,c);
+                                    }
+                                }
+                            }
+                        }
+                        for(int l = 0; l < nr_img; l++)
+                            dst[l][rWidth + j] = c[l];
+                    }
+                }
+            }
+        };
+        //!calculate the mean of every windowSizexWindwoSize block from the integral Image
+        //!this is a preprocessing for MV kernel
+        class MeanKernelIntegralImage : public ParallelLoopBody
+        {
+        private:
+            int *img;
+            int windowSize,width;
+            float scalling;
+            int *c;
+        public:
+            MeanKernelIntegralImage(const cv::Mat &image, int window,float scale, int *cost):
+                img((int *)image.data),windowSize(window) ,width(image.cols) ,scalling(scale) , c(cost){};
+            void operator()(const cv::Range &r) const{
+                for (int i = r.start; i <= r.end; i++)
+                {
+                    int iw = i * width;
+                    for (int j = windowSize + 1; j <= width - windowSize - 1; j++)
+                    {
+                        c[iw + j] = (int)((img[(i + windowSize - 1) * width + j + windowSize - 1] + img[(i - windowSize - 1) * width + j - windowSize - 1]
+                        - img[(i + windowSize) * width + j - windowSize] - img[(i - windowSize) * width + j + windowSize]) * scalling);
+                    }
+                }
+            }
+        };
+        //!implementation for the star kernel descriptor
+        template<int num_images>
+        class StarKernelCensus:public ParallelLoopBody
+        {
+        private:
+            uint8_t *image[num_images];
+            int *dst[num_images];
+            int n2, width, height, im_num,stride_;
+        public:
+            StarKernelCensus(const cv::Mat *img, int k2, int **distance)
+            {
+                for(int i = 0; i < num_images; i++)
+                {
+                    image[i] = img[i].data;
+                    dst[i] = distance[i];
+                }
+                n2 = k2;
+                width = img[0].cols;
+                height = img[0].rows;
+                im_num = num_images;
+                stride_ = (int)img[0].step;
+            }
+            void operator()(const cv::Range &r) const {
+                for (int i = r.start; i <= r.end ; i++)
+                {
+                    int rWidth = i * stride_;
+                    for (int j = n2; j <= width - n2; j++)
+                    {
+                        for(int d = 0 ; d < im_num; d++)
+                        {
+                            int c = 0;
+                            for(int step = 4; step > 0; step--)
+                            {
+                                for (int ii = i - step; ii <= i + step; ii += step)
+                                {
+                                    int rrWidth = ii * stride_;
+                                    for (int jj = j - step; jj <= j + step; jj += step)
+                                    {
+                                        if (image[d][rrWidth + jj] > image[d][rWidth + j])
+                                        {
+                                            c = c + 1;
+                                        }
+                                        c = c * 2;
+                                    }
+                                }
+                            }
+                            for (int ii = -1; ii <= +1; ii++)
+                            {
+                                int rrWidth = (ii + i) * stride_;
+                                if (i == -1)
+                                {
+                                    if (ii + i != i)
+                                    {
+                                        if (image[d][rrWidth + j] > image[d][rWidth + j])
+                                        {
+                                            c = c + 1;
+                                        }
+                                        c = c * 2;
+                                    }
+                                }
+                                else if (i == 0)
+                                {
+                                    for (int j2 = -1; j2 <= 1; j2 += 2)
+                                    {
+                                        if (ii + i != i)
+                                        {
+                                            if (image[d][rrWidth + j + j2] > image[d][rWidth + j])
+                                            {
+                                                c = c + 1;
+                                            }
+                                            c = c * 2;
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    if (ii + i != i)
+                                    {
+                                        if (image[d][rrWidth + j] > image[d][rWidth + j])
+                                        {
+                                            c = c + 1;
+                                        }
+                                        c = c * 2;
+                                    }
+                                }
+                            }
+                            dst[d][rWidth + j] = c;
+                        }
+                    }
+                }
+            }
+        };
+        //!paralel implementation of the center symetric census
+        template <int num_images>
+        class SymetricCensus:public ParallelLoopBody
+        {
+        private:
+            uint8_t *image[num_images];
+            int *dst[num_images];
+            int n2, width, height, im_num,stride_;
+        public:
+            SymetricCensus(const cv::Mat *img, int k2, int **distance)
+            {
+                for(int i = 0; i < num_images; i++)
+                {
+                    image[i] = img[i].data;
+                    dst[i] = distance[i];
+                }
+                n2 = k2;
+                width = img[0].cols;
+                height = img[0].rows;
+                im_num = num_images;
+                stride_ = (int)img[0].step;
+            }
+            void operator()(const cv::Range &r) const {
+                for (int i = r.start; i <= r.end ; i++)
+                {
+                    int distV = i*stride_;
+                    for (int j = n2; j <= width - n2; j++)
+                    {
+                        for(int d = 0; d < im_num; d++)
+                        {
+                            int c = 0;
+                            //the classic center symetric census which compares the curent pixel with its symetric not its center.
+                            for (int ii = -n2; ii <= 0; ii++)
+                            {
+                                int rrWidth = (ii + i) * stride_;
+                                for (int jj = -n2; jj <= +n2; jj++)
+                                {
+                                    if (image[d][(rrWidth + (jj + j))] > image[d][((ii * (-1) + i) * width + (-1 * jj) + j)])
+                                    {
+                                        c = c + 1;
+                                    }
+                                    c = c * 2;
+                                    if(ii == 0 && jj < 0)
+                                    {
+                                        if (image[d][(i * width + (jj + j))] > image[d][(i * width + (-1 * jj) + j)])
+                                        {
+                                            c = c + 1;
+                                        }
+                                        c = c * 2;
+                                    }
+                                }
+                            }
+                            dst[d][(distV + j)] = c;
+                        }
+                    }
+                }
+            }
+        };
+        /**
+        Two variations of census applied on input images
+        Implementation of a census transform which is taking into account just the some pixels from the census kernel thus allowing for larger block sizes
+        **/
+        //void applyCensusOnImages(const cv::Mat &im1,const cv::Mat &im2, int kernelSize, cv::Mat &dist, cv::Mat &dist2, const int type);
+        CV_EXPORTS void censusTransform(const cv::Mat &image1, const cv::Mat &image2, int kernelSize, cv::Mat &dist1, cv::Mat &dist2, const int type);
+        //single image census transform
+        CV_EXPORTS void censusTransform(const cv::Mat &image1, int kernelSize, cv::Mat &dist1, const int type);
+        /**
+        STANDARD_MCT - Modified census which is memorizing for each pixel 2 bits and includes a tolerance to the pixel comparison
+        MCT_MEAN_VARIATION - Implementation of a modified census transform which is also taking into account the variation to the mean of the window not just the center pixel
+        **/
+        CV_EXPORTS void modifiedCensusTransform(const cv::Mat &img1, const cv::Mat &img2, int kernelSize, cv::Mat &dist1,cv::Mat &dist2, const int type, int t = 0 , const cv::Mat &IntegralImage1 = cv::Mat::zeros(100,100,CV_8UC1), const cv::Mat &IntegralImage2 = cv::Mat::zeros(100,100,CV_8UC1));
+        //single version of modified census transform descriptor
+        CV_EXPORTS void modifiedCensusTransform(const cv::Mat &img1, int kernelSize, cv::Mat &dist, const int type, int t = 0 ,const cv::Mat &IntegralImage = cv::Mat::zeros(100,100,CV_8UC1));
+        /**The classical center symetric census
+        A modified version of cs census which is comparing a pixel with its correspondent after the center
+        **/
+        CV_EXPORTS void symetricCensusTransform(const cv::Mat &img1, const cv::Mat &img2, int kernelSize, cv::Mat &dist1, cv::Mat &dist2, const int type);
+        //single version of census transform
+        CV_EXPORTS void symetricCensusTransform(const cv::Mat &img1, int kernelSize, cv::Mat &dist1, const int type);
+        //in a 9x9 kernel only certain positions are choosen
+        CV_EXPORTS void starCensusTransform(const cv::Mat &img1, const cv::Mat &img2, int kernelSize, cv::Mat &dist1,cv::Mat &dist2);
+        //single image version of star kernel
+        CV_EXPORTS void starCensusTransform(const cv::Mat &img1, int kernelSize, cv::Mat &dist);
+        //integral image computation used in the Mean Variation Census Transform
+        void imageMeanKernelSize(const cv::Mat &img, int windowSize, cv::Mat &c);
+    }
+}
+#endif
+#endif
+/*End of file*/
diff --git a/thirdparty/linux/include/opencv2/stereo/matching.hpp b/thirdparty/linux/include/opencv2/stereo/matching.hpp
new file mode 100644
index 0000000..2238961
--- /dev/null
+++ b/thirdparty/linux/include/opencv2/stereo/matching.hpp
@@ -0,0 +1,624 @@
+//By downloading, copying, installing or using the software you agree to this license.
+//If you do not agree to this license, do not download, install,
+//copy or use the software.
+//
+//
+//                          License Agreement
+//               For Open Source Computer Vision Library
+//                       (3-clause BSD License)
+//
+//Copyright (C) 2000-2015, Intel Corporation, all rights reserved.
+//Copyright (C) 2009-2011, Willow Garage Inc., all rights reserved.
+//Copyright (C) 2009-2015, NVIDIA Corporation, all rights reserved.
+//Copyright (C) 2010-2013, Advanced Micro Devices, Inc., all rights reserved.
+//Copyright (C) 2015, OpenCV Foundation, all rights reserved.
+//Copyright (C) 2015, Itseez Inc., all rights reserved.
+//Third party copyrights are property of their respective owners.
+//
+//Redistribution and use in source and binary forms, with or without modification,
+//are permitted provided that the following conditions are met:
+//
+//  * Redistributions of source code must retain the above copyright notice,
+//    this list of conditions and the following disclaimer.
+//
+//  * Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+//  * Neither the names of the copyright holders nor the names of the contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+//This software is provided by the copyright holders and contributors "as is" and
+//any express or implied warranties, including, but not limited to, the implied
+//warranties of merchantability and fitness for a particular purpose are disclaimed.
+//In no event shall copyright holders or contributors be liable for any direct,
+//indirect, incidental, special, exemplary, or consequential damages
+//(including, but not limited to, procurement of substitute goods or services;
+//loss of use, data, or profits; or business interruption) however caused
+//and on any theory of liability, whether in contract, strict liability,
+//or tort (including negligence or otherwise) arising in any way out of
+//the use of this software, even if advised of the possibility of such damage.
+
+/*****************************************************************************************************************\
+*   The interface contains the main methods for computing the matching between the left and right images	      *
+*                                                                                                                 *
+\******************************************************************************************************************/
+#include <stdint.h>
+
+#ifndef _OPENCV_MATCHING_HPP_
+#define _OPENCV_MATCHING_HPP_
+#ifdef __cplusplus
+
+namespace cv
+{
+    namespace stereo
+    {
+        class Matching
+        {
+        private:
+            //!The maximum disparity
+            int maxDisparity;
+            //!the factor by which we are multiplying the disparity
+            int scallingFactor;
+            //!the confidence to which a min disparity found is good or not
+            double confidenceCheck;
+            //!the LUT used in case SSE is not available
+            int hamLut[65537];
+            //!function used for getting the minimum disparity from the cost volume"
+            static int minim(short *c, int iwpj, int widthDisp,const double confidence, const int search_region)
+            {
+                double mini, mini2, mini3;
+                mini = mini2 = mini3 = DBL_MAX;
+                int index = 0;
+                int iw = iwpj;
+                int widthDisp2;
+                widthDisp2 = widthDisp;
+                widthDisp -= 1;
+                for (int i = 0; i <= widthDisp; i++)
+                {
+                    if (c[(iw + i * search_region) * widthDisp2 + i] < mini)
+                    {
+                        mini3 = mini2;
+                        mini2 = mini;
+                        mini = c[(iw + i * search_region) * widthDisp2 + i];
+                        index = i;
+                    }
+                    else if (c[(iw + i * search_region) * widthDisp2 + i] < mini2)
+                    {
+                        mini3 = mini2;
+                        mini2 = c[(iw + i * search_region) * widthDisp2 + i];
+                    }
+                    else if (c[(iw + i * search_region) * widthDisp2 + i] < mini3)
+                    {
+                        mini3 = c[(iw + i * search_region) * widthDisp2 + i];
+                    }
+                }
+                if(mini != 0)
+                {
+                    if (mini3 / mini <= confidence)
+                        return index;
+                }
+                return -1;
+            }
+            //!Interpolate in order to obtain better results
+            //!function for refining the disparity at sub pixel using simetric v
+            static double symetricVInterpolation(short *c, int iwjp, int widthDisp, int winDisp,const int search_region)
+            {
+                if (winDisp == 0 || winDisp == widthDisp - 1)
+                    return winDisp;
+                double m2m1, m3m1, m3, m2, m1;
+                m2 = c[(iwjp + (winDisp - 1) * search_region) * widthDisp + winDisp - 1];
+                m3 = c[(iwjp + (winDisp + 1) * search_region)* widthDisp + winDisp + 1];
+                m1 = c[(iwjp + winDisp * search_region) * widthDisp + winDisp];
+                m2m1 = m2 - m1;
+                m3m1 = m3 - m1;
+                if (m2m1 == 0 || m3m1 == 0) return winDisp;
+                double p;
+                p = 0;
+                if (m2 > m3)
+                {
+                    p = (0.5 - 0.25 * ((m3m1 * m3m1) / (m2m1 * m2m1) + (m3m1 / m2m1)));
+                }
+                else
+                {
+                    p = -1 * (0.5 - 0.25 * ((m2m1 * m2m1) / (m3m1 * m3m1) + (m2m1 / m3m1)));
+                }
+                if (p >= -0.5 && p <= 0.5)
+                    p = winDisp + p;
+                return p;
+            }
+            //!a pre processing function that generates the Hamming LUT in case the algorithm will ever be used on platform where SSE is not available
+            void hammingLut()
+            {
+                for (int i = 0; i <= 65536; i++)
+                {
+                    int dist = 0;
+                    int j = i;
+                    //we number the bits from our number
+                    while (j)
+                    {
+                        dist = dist + 1;
+                        j = j & (j - 1);
+                    }
+                    hamLut[i] = dist;
+                }
+            }
+            //!the class used in computing the hamming distance
+            class hammingDistance : public ParallelLoopBody
+            {
+            private:
+                int *left, *right;
+                short *c;
+                int v,kernelSize, width;
+                int MASK;
+                int *hammLut;
+            public :
+                hammingDistance(const Mat &leftImage, const Mat &rightImage, short *cost, int maxDisp, int kerSize, int *hammingLUT):
+                    left((int *)leftImage.data), right((int *)rightImage.data), c(cost), v(maxDisp),kernelSize(kerSize),width(leftImage.cols), MASK(65535), hammLut(hammingLUT){}
+                void operator()(const cv::Range &r) const {
+                    for (int i = r.start; i <= r.end ; i++)
+                    {
+                        int iw = i * width;
+                        for (int j = kernelSize; j < width - kernelSize; j++)
+                        {
+                            int j2;
+                            int xorul;
+                            int iwj;
+                            iwj = iw + j;
+                            for (int d = 0; d <= v; d++)
+                            {
+                                j2 = (0 > j - d) ? (0) : (j - d);
+                                xorul = left[(iwj)] ^ right[(iw + j2)];
+#if CV_POPCNT
+                                if (checkHardwareSupport(CV_CPU_POPCNT))
+                                {
+                                    c[(iwj)* (v + 1) + d] = (short)_mm_popcnt_u32(xorul);
+                                }
+                                else
+#endif
+                                {
+                                    c[(iwj)* (v + 1) + d] = (short)(hammLut[xorul & MASK] + hammLut[(xorul >> 16) & MASK]);
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            //!cost aggregation
+            class agregateCost:public ParallelLoopBody
+            {
+            private:
+                int win;
+                short *c, *parSum;
+                int maxDisp,width, height;
+            public:
+                agregateCost(const Mat &partialSums, int windowSize, int maxDispa, Mat &cost)
+                {
+                    win = windowSize / 2;
+                    c = (short *)cost.data;
+                    maxDisp = maxDispa;
+                    width = cost.cols / ( maxDisp + 1) - 1;
+                    height = cost.rows - 1;
+                    parSum = (short *)partialSums.data;
+                }
+                void operator()(const cv::Range &r) const {
+                    for (int i = r.start; i <= r.end; i++)
+                    {
+                        int iwi = (i - 1) * width;
+                        for (int j = win + 1; j <= width - win - 1; j++)
+                        {
+                            int w1 = ((i + win + 1) * width + j + win) * (maxDisp + 1);
+                            int w2 = ((i - win) * width + j - win - 1) * (maxDisp + 1);
+                            int w3 = ((i + win + 1) * width + j - win - 1) * (maxDisp + 1);
+                            int w4 = ((i - win) * width + j + win) * (maxDisp + 1);
+                            int w = (iwi + j - 1) * (maxDisp + 1);
+                            for (int d = 0; d <= maxDisp; d++)
+                            {
+                                c[w + d] = parSum[w1 + d] + parSum[w2 + d]
+                                - parSum[w3 + d] - parSum[w4 + d];
+                            }
+                        }
+                    }
+                }
+            };
+            //!class that is responsable for generating the disparity map
+            class makeMap:public ParallelLoopBody
+            {
+            private:
+                //enum used to notify wether we are searching on the vertical ie (lr) or diagonal (rl)
+                enum {CV_VERTICAL_SEARCH, CV_DIAGONAL_SEARCH};
+                int width,disparity,scallingFact,th;
+                double confCheck;
+                uint8_t *map;
+                short *c;
+            public:
+                makeMap(const Mat &costVolume, int threshold, int maxDisp, double confidence,int scale, Mat &mapFinal)
+                {
+                    c = (short *)costVolume.data;
+                    map = mapFinal.data;
+                    disparity = maxDisp;
+                    width = costVolume.cols / ( disparity + 1) - 1;
+                    th = threshold;
+                    scallingFact = scale;
+                    confCheck = confidence;
+                }
+                void operator()(const cv::Range &r) const {
+                    for (int i = r.start; i <= r.end ; i++)
+                    {
+                        int lr;
+                        int v = -1;
+                        double p1, p2;
+                        int iw = i * width;
+                        for (int j = 0; j < width; j++)
+                        {
+                            lr = Matching:: minim(c, iw + j, disparity + 1, confCheck,CV_VERTICAL_SEARCH);
+                            if (lr != -1)
+                            {
+                                v = Matching::minim(c, iw + j - lr, disparity + 1, confCheck,CV_DIAGONAL_SEARCH);
+                                if (v != -1)
+                                {
+                                    p1 = Matching::symetricVInterpolation(c, iw + j - lr, disparity + 1, v,CV_DIAGONAL_SEARCH);
+                                    p2 = Matching::symetricVInterpolation(c, iw + j, disparity + 1, lr,CV_VERTICAL_SEARCH);
+                                    if (abs(p1 - p2) <= th)
+                                        map[iw + j] = (uint8_t)((p2)* scallingFact);
+                                    else
+                                    {
+                                        map[iw + j] = 0;
+                                    }
+                                }
+                                else
+                                {
+                                    if (width - j <= disparity)
+                                    {
+                                        p2 = Matching::symetricVInterpolation(c, iw + j, disparity + 1, lr,CV_VERTICAL_SEARCH);
+                                        map[iw + j] = (uint8_t)(p2* scallingFact);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                map[iw + j] = 0;
+                            }
+                        }
+                    }
+                }
+            };
+            //!median 1x9 paralelized filter
+            template <typename T>
+            class Median1x9:public ParallelLoopBody
+            {
+            private:
+                T *original;
+                T *filtered;
+                int height, width;
+            public:
+                Median1x9(const Mat &originalImage, Mat &filteredImage)
+                {
+                    original = (T *)originalImage.data;
+                    filtered = (T *)filteredImage.data;
+                    height = originalImage.rows;
+                    width = originalImage.cols;
+                }
+                void operator()(const cv::Range &r) const{
+                    for (int m = r.start; m <= r.end; m++)
+                    {
+                        for (int n = 4; n < width - 4; ++n)
+                        {
+                            int k = 0;
+                            T window[9];
+                            for (int i = n - 4; i <= n + 4; ++i)
+                                window[k++] = original[m * width + i];
+                            for (int j = 0; j < 5; ++j)
+                            {
+                                int min = j;
+                                for (int l = j + 1; l < 9; ++l)
+                                    if (window[l] < window[min])
+                                        min = l;
+                                const T temp = window[j];
+                                window[j] = window[min];
+                                window[min] = temp;
+                            }
+                            filtered[m  * width + n] = window[4];
+                        }
+                    }
+                }
+            };
+            //!median 9x1 paralelized filter
+            template <typename T>
+            class Median9x1:public ParallelLoopBody
+            {
+            private:
+                T *original;
+                T *filtered;
+                int height, width;
+            public:
+                Median9x1(const Mat &originalImage, Mat &filteredImage)
+                {
+                    original = (T *)originalImage.data;
+                    filtered = (T *)filteredImage.data;
+                    height = originalImage.rows;
+                    width = originalImage.cols;
+                }
+                void operator()(const Range &r) const{
+                    for (int n = r.start; n <= r.end; ++n)
+                    {
+                        for (int m = 4; m < height - 4; ++m)
+                        {
+                            int k = 0;
+                            T window[9];
+                            for (int i = m - 4; i <= m + 4; ++i)
+                                window[k++] = original[i * width + n];
+                            for (int j = 0; j < 5; j++)
+                            {
+                                int min = j;
+                                for (int l = j + 1; l < 9; ++l)
+                                    if (window[l] < window[min])
+                                        min = l;
+                                const T temp = window[j];
+                                window[j] = window[min];
+                                window[min] = temp;
+                            }
+                            filtered[m  * width + n] = window[4];
+                        }
+                    }
+                }
+            };
+        protected:
+            //arrays used in the region removal
+            Mat speckleY;
+            Mat speckleX;
+            Mat puss;
+            //int *specklePointX;
+            //int *specklePointY;
+            //long long *pus;
+            int previous_size;
+            //!method for setting the maximum disparity
+            void setMaxDisparity(int val)
+            {
+                CV_Assert(val > 10);
+                this->maxDisparity = val;
+            }
+            //!method for getting the disparity
+            int getMaxDisparity()
+            {
+                return this->maxDisparity;
+            }
+            //! a number by which the disparity will be multiplied for better display
+            void setScallingFactor(int val)
+            {
+                CV_Assert(val > 0);
+                this->scallingFactor = val;
+            }
+            //!method for getting the scalling factor
+            int getScallingFactor()
+            {
+                return scallingFactor;
+            }
+            //!setter for the confidence check
+            void setConfidence(double val)
+            {
+                CV_Assert(val >= 1);
+                this->confidenceCheck = val;
+            }
+            //getter for confidence check
+            double getConfidence()
+            {
+                return confidenceCheck;
+            }
+            //! Hamming distance computation method
+            //! leftImage and rightImage are the two transformed images
+            //! the cost is the resulted cost volume and kernel Size is the size of the matching window
+            void hammingDistanceBlockMatching(const Mat &leftImage, const Mat &rightImage, Mat &cost, const int kernelSize= 9)
+            {
+                CV_Assert(leftImage.cols == rightImage.cols);
+                CV_Assert(leftImage.rows == rightImage.rows);
+                CV_Assert(kernelSize % 2 != 0);
+                CV_Assert(cost.rows == leftImage.rows);
+                CV_Assert(cost.cols / (maxDisparity + 1) == leftImage.cols);
+                short *c = (short *)cost.data;
+                memset(c, 0, sizeof(c[0]) * leftImage.cols * leftImage.rows * (maxDisparity + 1));
+                parallel_for_(cv::Range(kernelSize / 2,leftImage.rows - kernelSize / 2), hammingDistance(leftImage,rightImage,(short *)cost.data,maxDisparity,kernelSize / 2,hamLut));
+            }
+            //preprocessing the cost volume in order to get it ready for aggregation
+            void costGathering(const Mat &hammingDistanceCost, Mat &cost)
+            {
+                CV_Assert(hammingDistanceCost.rows == hammingDistanceCost.rows);
+                CV_Assert(hammingDistanceCost.type() == CV_16S);
+                CV_Assert(cost.type() == CV_16S);
+                int maxDisp = maxDisparity;
+                int width = cost.cols / ( maxDisp + 1) - 1;
+                int height = cost.rows - 1;
+                short *c = (short *)cost.data;
+                short *ham = (short *)hammingDistanceCost.data;
+                memset(c, 0, sizeof(c[0]) * (width + 1) * (height + 1) * (maxDisp + 1));
+                for (int i = 1; i <= height; i++)
+                {
+                    int iw = i * width;
+                    int iwi = (i - 1) * width;
+                    for (int j = 1; j <= width; j++)
+                    {
+                        int iwj = (iw + j) * (maxDisp + 1);
+                        int iwjmu = (iw + j - 1) * (maxDisp + 1);
+                        int iwijmu = (iwi + j - 1) * (maxDisp + 1);
+                        for (int d = 0; d <= maxDisp; d++)
+                        {
+                            c[iwj + d] = ham[iwijmu + d] + c[iwjmu + d];
+                        }
+                    }
+                }
+                for (int i = 1; i <= height; i++)
+                {
+                    for (int j = 1; j <= width; j++)
+                    {
+                        int iwj = (i * width + j) * (maxDisp + 1);
+                        int iwjmu = ((i - 1)  * width + j) * (maxDisp + 1);
+                        for (int d = 0; d <= maxDisp; d++)
+                        {
+                            c[iwj + d] += c[iwjmu + d];
+                        }
+                    }
+                }
+            }
+            //!The aggregation on the cost volume
+            void blockAgregation(const Mat &partialSums, int windowSize, Mat &cost)
+            {
+                CV_Assert(windowSize % 2 != 0);
+                CV_Assert(partialSums.rows == cost.rows);
+                CV_Assert(partialSums.cols == cost.cols);
+                int win = windowSize / 2;
+                short *c = (short *)cost.data;
+                int maxDisp = maxDisparity;
+                int width = cost.cols / ( maxDisp + 1) - 1;
+                int height = cost.rows - 1;
+                memset(c, 0, sizeof(c[0]) * width * height * (maxDisp + 1));
+                parallel_for_(cv::Range(win + 1,height - win - 1), agregateCost(partialSums,windowSize,maxDisp,cost));
+            }
+            //!remove small regions that have an area smaller than t, we fill the region with the average of the good pixels around it
+            template <typename T>
+            void smallRegionRemoval(const Mat &currentMap, int t, Mat &out)
+            {
+                CV_Assert(currentMap.cols == out.cols);
+                CV_Assert(currentMap.rows == out.rows);
+                CV_Assert(t >= 0);
+                int *pus = (int *)puss.data;
+                int *specklePointX = (int *)speckleX.data;
+                int *specklePointY = (int *)speckleY.data;
+                memset(pus, 0, previous_size * sizeof(pus[0]));
+                T *map = (T *)currentMap.data;
+                T *outputMap = (T *)out.data;
+                int height = currentMap.rows;
+                int width = currentMap.cols;
+                T k = 1;
+                int st, dr;
+                int di[] = { -1, -1, -1, 0, 1, 1, 1, 0 },
+                    dj[] = { -1, 0, 1, 1, 1, 0, -1, -1 };
+                int speckle_size = 0;
+                st = 0;
+                dr = 0;
+                for (int i = 1; i < height - 1; i++)
+                {
+                    int iw = i * width;
+                    for (int j = 1; j < width - 1; j++)
+                    {
+                        if (map[iw + j] != 0)
+                        {
+                            outputMap[iw + j] = map[iw + j];
+                        }
+                        else if (map[iw + j] == 0)
+                        {
+                            T nr = 1;
+                            T avg = 0;
+                            speckle_size = dr;
+                            specklePointX[dr] = i;
+                            specklePointY[dr] = j;
+                            pus[i * width + j] = 1;
+                            dr++;
+                            map[iw + j] = k;
+                            while (st < dr)
+                            {
+                                int ii = specklePointX[st];
+                                int jj = specklePointY[st];
+                                //going on 8 directions
+                                for (int d = 0; d < 8; d++)
+                                {//if insisde
+                                    if (ii + di[d] >= 0 && ii + di[d] < height && jj + dj[d] >= 0 && jj + dj[d] < width &&
+                                        pus[(ii + di[d]) * width + jj + dj[d]] == 0)
+                                    {
+                                        T val = map[(ii + di[d]) * width + jj + dj[d]];
+                                        if (val == 0)
+                                        {
+                                            map[(ii + di[d]) * width + jj + dj[d]] = k;
+                                            specklePointX[dr] = (ii + di[d]);
+                                            specklePointY[dr] = (jj + dj[d]);
+                                            dr++;
+                                            pus[(ii + di[d]) * width + jj + dj[d]] = 1;
+                                        }//this means that my point is a good point to be used in computing the final filling value
+                                        else if (val >= 1 && val < 250)
+                                        {
+                                            avg += val;
+                                            nr++;
+                                        }
+                                    }
+                                }
+                                st++;
+                            }//if hole size is smaller than a specified threshold we fill the respective hole with the average of the good neighbours
+                            if (st - speckle_size <= t)
+                            {
+                                T fillValue = (T)(avg / nr);
+                                while (speckle_size < st)
+                                {
+                                    int ii = specklePointX[speckle_size];
+                                    int jj = specklePointY[speckle_size];
+                                    outputMap[ii * width + jj] = fillValue;
+                                    speckle_size++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            //!Method responsible for generating the disparity map
+            //!function for generating disparity maps at sub pixel level
+            /* costVolume - represents the cost volume
+            * width, height - represent the width and height of the iage
+            *disparity - represents the maximum disparity
+            *map - is the disparity map that will result
+            *th - is the LR threshold
+            */
+            void dispartyMapFormation(const Mat &costVolume, Mat &mapFinal, int th)
+            {
+                uint8_t *map = mapFinal.data;
+                int disparity = maxDisparity;
+                int width = costVolume.cols / ( disparity + 1) - 1;
+                int height = costVolume.rows - 1;
+                memset(map, 0, sizeof(map[0]) * width * height);
+                parallel_for_(Range(0,height - 1), makeMap(costVolume,th,disparity,confidenceCheck,scallingFactor,mapFinal));
+            }
+        public:
+            //!a median filter of 1x9 and 9x1
+            //!1x9 median filter
+            template<typename T>
+            void Median1x9Filter(const Mat &originalImage, Mat &filteredImage)
+            {
+                CV_Assert(originalImage.rows == filteredImage.rows);
+                CV_Assert(originalImage.cols == filteredImage.cols);
+                parallel_for_(Range(1,originalImage.rows - 2), Median1x9<T>(originalImage,filteredImage));
+            }
+            //!9x1 median filter
+            template<typename T>
+            void Median9x1Filter(const Mat &originalImage, Mat &filteredImage)
+            {
+                CV_Assert(originalImage.cols == filteredImage.cols);
+                CV_Assert(originalImage.cols == filteredImage.cols);
+                parallel_for_(Range(1,originalImage.cols - 2), Median9x1<T>(originalImage,filteredImage));
+            }
+            //!constructor for the matching class
+            //!maxDisp - represents the maximum disparity
+            Matching(void)
+            {
+                hammingLut();
+            }
+            ~Matching(void)
+            {
+            }
+            //constructor for the matching class
+            //maxDisp - represents the maximum disparity
+            //confidence - represents the confidence check
+            Matching(int maxDisp, int scalling = 4, int confidence = 6)
+            {
+                //set the maximum disparity
+                setMaxDisparity(maxDisp);
+                //set scalling factor
+                setScallingFactor(scalling);
+                //set the value for the confidence
+                setConfidence(confidence);
+                //generate the hamming lut in case SSE is not available
+                hammingLut();
+            }
+        };
+    }
+}
+#endif
+#endif
+/*End of file*/
diff --git a/thirdparty/linux/include/opencv2/stereo/stereo.hpp b/thirdparty/linux/include/opencv2/stereo/stereo.hpp
new file mode 100644
index 0000000..bab7c41
--- /dev/null
+++ b/thirdparty/linux/include/opencv2/stereo/stereo.hpp
@@ -0,0 +1,49 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/stereo.hpp"
+