~paparazzi-uav/paparazzi/v5.0-manual

void stereoBM_CUDA(const PtrStepSzb& left, const PtrStepSzb& right, const PtrStepSzb& disp, int ndisp, int winsz, const PtrStepSz<unsigned int>& minSSD_buf, cudaStream_t & stream);

void prefilter_xsobel(const PtrStepSzb& input, const PtrStepSzb& output, int prefilterCap /*= 31*/, cudaStream_t & stream);

void postfilter_textureness(const PtrStepSzb& input, int winsz, float avgTexturenessThreshold, const PtrStepSzb& disp, cudaStream_t & stream);

}

}}}

namespace

{

class StereoBMImpl : public cuda::StereoBM

{

public:

StereoBMImpl(int numDisparities, int blockSize);

void compute(InputArray left, InputArray right, OutputArray disparity);

void compute(InputArray left, InputArray right, OutputArray disparity, Stream& stream);

int getMinDisparity() const { return 0; }

void setMinDisparity(int /*minDisparity*/) {}

int getNumDisparities() const { return ndisp_; }

void setNumDisparities(int numDisparities) { ndisp_ = numDisparities; }

int getBlockSize() const { return winSize_; }

void setBlockSize(int blockSize) { winSize_ = blockSize; }

int getSpeckleWindowSize() const { return 0; }

void setSpeckleWindowSize(int /*speckleWindowSize*/) {}

int getSpeckleRange() const { return 0; }

void setSpeckleRange(int /*speckleRange*/) {}

int getDisp12MaxDiff() const { return 0; }

void setDisp12MaxDiff(int /*disp12MaxDiff*/) {}

int getPreFilterType() const { return preset_; }

void setPreFilterType(int preFilterType) { preset_ = preFilterType; }

int getPreFilterSize() const { return 0; }

void setPreFilterSize(int /*preFilterSize*/) {}

int getPreFilterCap() const { return preFilterCap_; }

void setPreFilterCap(int preFilterCap) { preFilterCap_ = preFilterCap; }

100

101

int getTextureThreshold() const { return static_cast<int>(avergeTexThreshold_); }

102

void setTextureThreshold(int textureThreshold) { avergeTexThreshold_ = static_cast<float>(textureThreshold); }

103

104

int getUniquenessRatio() const { return 0; }

105

void setUniquenessRatio(int /*uniquenessRatio*/) {}

106

107

int getSmallerBlockSize() const { return 0; }

108

void setSmallerBlockSize(int /*blockSize*/){}

109

110

Rect getROI1() const { return Rect(); }

111

void setROI1(Rect /*roi1*/) {}

112

113

Rect getROI2() const { return Rect(); }

114

void setROI2(Rect /*roi2*/) {}

115

116

private:

117

int preset_;

118

int ndisp_;

119

int winSize_;

120

int preFilterCap_;

121

float avergeTexThreshold_;

122

123

GpuMat minSSD_, leBuf_, riBuf_;

124

};

125

126

StereoBMImpl::StereoBMImpl(int numDisparities, int blockSize)

127

: preset_(0), ndisp_(numDisparities), winSize_(blockSize), preFilterCap_(31), avergeTexThreshold_(3)

128

{

129

}

130

131

void StereoBMImpl::compute(InputArray left, InputArray right, OutputArray disparity)

132

{

133

compute(left, right, disparity, Stream::Null());

134

}

135

136

void StereoBMImpl::compute(InputArray _left, InputArray _right, OutputArray _disparity, Stream& _stream)

137

{

138

using namespace ::cv::cuda::device::stereobm;

139

140

const int max_supported_ndisp = 1 << (sizeof(unsigned char) * 8);

141

CV_Assert( 0 < ndisp_ && ndisp_ <= max_supported_ndisp );

142

CV_Assert( ndisp_ % 8 == 0 );

143

CV_Assert( winSize_ % 2 == 1 );

144

145

GpuMat left = _left.getGpuMat();

146

GpuMat right = _right.getGpuMat();

147

148

CV_Assert( left.type() == CV_8UC1 );

149

CV_Assert( left.size() == right.size() && left.type() == right.type() );

150

151

_disparity.create(left.size(), CV_8UC1);

152

GpuMat disparity = _disparity.getGpuMat();

153

154

cudaStream_t stream = StreamAccessor::getStream(_stream);

155

156

cuda::ensureSizeIsEnough(left.size(), CV_32SC1, minSSD_);

157

158

PtrStepSzb le_for_bm = left;

159

PtrStepSzb ri_for_bm = right;

160

161

if (preset_ == cv::StereoBM::PREFILTER_XSOBEL)

162

{

163

cuda::ensureSizeIsEnough(left.size(), left.type(), leBuf_);

164

cuda::ensureSizeIsEnough(right.size(), right.type(), riBuf_);

165

166

prefilter_xsobel( left, leBuf_, preFilterCap_, stream);

167

prefilter_xsobel(right, riBuf_, preFilterCap_, stream);

168

169

le_for_bm = leBuf_;

170

ri_for_bm = riBuf_;

171

}

172

173

stereoBM_CUDA(le_for_bm, ri_for_bm, disparity, ndisp_, winSize_, minSSD_, stream);

174

175

if (avergeTexThreshold_ > 0)

176

postfilter_textureness(le_for_bm, winSize_, avergeTexThreshold_, disparity, stream);

177

}

178

}

179

180

Ptr<cuda::StereoBM> cv::cuda::createStereoBM(int numDisparities, int blockSize)

181

{

182

return makePtr<StereoBMImpl>(numDisparities, blockSize);

183

}

184

185

#endif /* !defined (HAVE_CUDA) */

Older »