Maximum disparity has to be 128

[arrfou90]

Hello Daniel,
I want to increase the disparity level to more than 256. But I assume this a limitation (I guess it is the GPU memory size limitation), Is that possible to increase the disparity level even with low image resolution.
Thanks in advance
Arrfou

[dhernandez0]

This is limited to 128 because of some specific optimizations, basically, each thread computed 4 disparity values, so, 128/4 = 32. Therefore, we only need 32 threads (1 warp) doing computation, so, we can use: SIMD instructions, warp shuffle, etc...

This is possible to change, I think (I'm not sure) it should not be difficult to change it to 256 by using uint64_t instead of uint32_t and chaging some code. However, I don't have time to do this now, if you can do it, I could help you if you have any questions.

[smmmmi]

Any updates @arrfou90 ?

[yaobaishen]

Disparity 256 would be very helpful for long baseline stereo camera to detect near objects.

[yaobaishen]

I just give a try that latest code could support MAX_DISPARITY 256, but the disparity view of very near object don't look great, the ground also may have many noise, does the sgm algorithm is sensitive to the light condition when image captured?

[yaobaishen]

@dhernandez0 I look into the code and find that if change cost_t from uint32_t to uint64_t, I have to change several inline functions in the util.h as they are written with 32bit asm, if there are any other tips that I should pay attention to? thanks

[dhernandez0]

Hi @yaobaishen
See my original response to this request, the assumption that maximum disparity is 128 is used in all the code. But the cost_t represents cost computed by the census transform, so it does not change if you change the maximum disparity.

You should change the way memory is read from d_transform1 and d_transform0. Right now, we use a 32 threads for each pixel, each thread then computes the 4 disparities. You should change the code to make each thread compute 8 disparities. For example, right now we read a uint32_t from the cost cube which is the vector of 4 costs that correspond to the thread:

sgm/cost_aggregation.h

Line 153 in 6356323

*old_values = ld_gbl_ca(reinterpret_cast<const uint32_t*>(&d_cost[index]));

[yaobaishen]

@dhernandez0 Thanks for advice!

[yaobaishen]

@dhernandez0 During implement the code I encounter another problem, as my current knowledge, CUDA doesn't support 64bit asm operation regarding to the code you paste above, so I just read twice, for example:
old_values = ld_gbl_ca(reinterpret_cast<const uint32_t>(&d_cost[index]));
old_values2 = ld_gbl_ca(reinterpret_cast<const uint32_t>(&d_cost[index + 4]));
So I don''t use uint64_t at all, but copy each parameter twice, and modify the CostAggregationGenericIteration() to computes 8 disparities. After this, the disparity map messed up, I am still debugging, so I want to confirm if I misunderstand something... Thanks a lot

[peterjiangjun]

@dhernandez0 During implement the code I encounter another problem, as my current knowledge, CUDA doesn't support 64bit asm operation regarding to the code you paste above, so I just read twice, for example:
_old_values = ld_gbl_ca(reinterpret_cast(&d_cost[index]));
_old_values2 = ld_gbl_ca(reinterpret_cast(&d_cost[index + 4]));
So I don''t use uint64_t at all, but copy each parameter twice, and modify the CostAggregationGenericIteration() to computes 8 disparities. After this, the disparity map messed up, I am still debugging, so I want to confirm if I misunderstand something... Thanks a lot

您好，请问你有把最大视差值超过128的功能完成吗？如果完成，不知道方不方便分享一下，新手，不会改，只能求助您帮助啦。

[peterjiangjun]

@dhernandez0 During implement the code I encounter another problem, as my current knowledge, CUDA doesn't support 64bit asm operation regarding to the code you paste above, so I just read twice, for example:
_old_values = ld_gbl_ca(reinterpret_cast(&d_cost[index]));
_old_values2 = ld_gbl_ca(reinterpret_cast(&d_cost[index + 4]));
So I don''t use uint64_t at all, but copy each parameter twice, and modify the CostAggregationGenericIteration() to computes 8 disparities. After this, the disparity map messed up, I am still debugging, so I want to confirm if I misunderstand something... Thanks a lot

您好，请问你有把最大视差值超过128的功能完成吗？如果完成，不知道方不方便分享一下，新手，不会改，只能求助您帮助啦。

@dhernandez0 During implement the code I encounter another problem, as my current knowledge, CUDA doesn't support 64bit asm operation regarding to the code you paste above, so I just read twice, for example:
_old_values = ld_gbl_ca(reinterpret_cast(&d_cost[index]));
_old_values2 = ld_gbl_ca(reinterpret_cast(&d_cost[index + 4]));
So I don''t use uint64_t at all, but copy each parameter twice, and modify the CostAggregationGenericIteration() to computes 8 disparities. After this, the disparity map messed up, I am still debugging, so I want to confirm if I misunderstand something... Thanks a lot

[ynma-hanvo]

Hi @yaobaishen See my original response to this request, the assumption that maximum disparity is 128 is used in all the code. But the cost_t represents cost computed by the census transform, so it does not change if you change the maximum disparity.

You should change the way memory is read from d_transform1 and d_transform0. Right now, we use a 32 threads for each pixel, each thread then computes the 4 disparities. You should change the code to make each thread compute 8 disparities. For example, right now we read a uint32_t from the cost cube which is the vector of 4 costs that correspond to the thread:

sgm/cost_aggregation.h

Line 153 in 6356323

*old_values = ld_gbl_ca(reinterpret_cast<const uint32_t*>(&d_cost[index]));

hi, thanks for the clarify.
if i want to change MAX_DISPARITY to 64, any advice for it

[peterjiangjun]

收到了  。