Alexander Alekhin
5 years ago
commit
03730e1e67
14 changed files with 571 additions and 563 deletions
@ -1,2 +1,2 @@ |
||||
set(the_description "Stereo Correspondence") |
||||
ocv_define_module(stereo opencv_imgproc opencv_features2d opencv_core opencv_calib3d opencv_tracking opencv_video) |
||||
ocv_define_module(stereo opencv_imgproc opencv_features2d opencv_core opencv_tracking) |
||||
|
||||
@ -0,0 +1,412 @@ |
||||
//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 |
||||
{ |
||||
//!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 |
||||
{ |
||||
CV_UNUSED(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 |
||||
{ |
||||
CV_UNUSED(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 |
||||
{ |
||||
CV_UNUSED(j); |
||||
CV_UNUSED(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 |
||||
{ |
||||
CV_UNUSED(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 CV_OVERRIDE { |
||||
for (int i = r.start; i < r.end ; i++) |
||||
{ |
||||
int rWidth = i * stride_; |
||||
for (int j = 0; j < width; j++) |
||||
{ |
||||
if (i < n2 || i >= height - n2 || j < n2 + 2 || j >= width - n2 - 2) |
||||
{ |
||||
for(int l = 0; l < nr_img; l++) |
||||
dst[l][rWidth + j] = 0; // TODO out of range value?
|
||||
continue; |
||||
} |
||||
|
||||
int c[nr_img]; |
||||
memset(c, 0, sizeof(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]; |
||||
} |
||||
} |
||||
} |
||||
}; |
||||
//!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 CV_OVERRIDE { |
||||
for (int i = r.start; i < r.end; i++) |
||||
{ |
||||
int rWidth = i * stride_; |
||||
for (int j = 0; j < width; j++) |
||||
{ |
||||
for(int d = 0 ; d < im_num; d++) |
||||
{ |
||||
if (i < n2 || i >= height - n2 || j < n2 || j >= width - n2) |
||||
{ |
||||
dst[d][rWidth + j] = 0; // TODO out of range value?
|
||||
continue; |
||||
} |
||||
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 CV_OVERRIDE { |
||||
for (int i = r.start; i < r.end ; i++) |
||||
{ |
||||
int distV = i*stride_; |
||||
for (int j = 0; j < width; j++) |
||||
{ |
||||
for(int d = 0; d < im_num; d++) |
||||
{ |
||||
if (i < n2 || i >= height - n2 || j < n2 || j >= width - n2) |
||||
{ |
||||
dst[d][distV + j] = 0; // TODO out of range value?
|
||||
continue; |
||||
} |
||||
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; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
}; |
||||
} |
||||
} |
||||
#endif |
||||
#endif |
||||
/*End of file*/ |
||||
Loading…
Reference in new issue