作者：京东科技李大冲

一、Julia是什么

julia是2010年开始面世的语言，作为一个10后，Julia必然有前辈们没有的特点。Julia被期望塑造成原生的有C++的运行速度、python的易交互性以及胶水性。最重要的是，julia也是nVidia-cuda官方选中的接口语言，这点让cuda编程变得稍微容易一些。

二、项目背景

双目立体视觉是比较常规获取深度信息的算法。这是一种模仿人的双眼的方法，根据对同一个点在不同的视角进行观察，并在不同的观察视角上的观察差异推算出深度，这在图1中更清晰一点。被动双目的缺点是需要纹理特征去判断左右相机里是否为同一个点。也就是，当没有问题、纹理不够明显或者纹理重复时，这种方法难以工作。

被动双目示意图

观测点在一个相机和在另外一个相机上的成像是有明显可区分性的，二者的观察差异（L1和L2）形成了视差，进而可形成深度信息。

被动双目的缺点是某些场景下无效，主动双目便出现了。如果我们投射一些人工设定编码的图案，根据实现约定通过解码可以对视野内是所有点赋予唯一的标识符号，那被动双目的问题不就解决了吗。

事实上，人们很快发现可以使用空间上编码和时间上编码两种方式。空间上编码，就像人们观察银河命名星座一样，去投射随机生成的星星点点的光斑，没有纹理的夜空照射进了完全可辨识的图案。如同星座往往是一个空间范围很大的概念，空间编码的方式无法做到非常精细。所以，时间编码的方式应运而生，时间编码是投射一组图案，让被照射的区域，被照射的明暗变化情况是完全不一样的。

像图2中的二进制编码（或行业内称为格雷码），再加上灰度变化更加丰富的编码方式以及相机在竖方向上对齐之后是只需要考虑横轴方向上的差异这两点，可以实现全视野的点完全可区分。

空间编码和时间编码

空间编码如同银河中的星星点点，通过组合星点变为星座，人们可以对深邃夜空不同位置依靠银河区分开。时间编码是投射多组图案，让每一个点是时间上都有唯一的变化情况。就像右图，这16个方格都是完全可区分的。

三、效率问题

使用主动双目的结构去重建，一个很大的影响运行效率的问题是需要对左右图像求算视差（原理如图1所示）。具体求算视差的操作是要对左相机里的每一个点，去找右相机中同一行中与之距离最近的点的横坐标，然后继续插值之后找到距离更近的插值坐标，最后把这两个坐标的差异当作视差进行后续的计算。

使用时间编码的主动双目，按照实现约定的编码进行解码之后，其效果如图3所示，这个环节就是在这对数据上进行处理。以此数据为例，有效区域大概是700*850，完全遍历所需要的时间复杂度大概是O(700*850*850)，直接估算就很耗时。

时间编码解码后的图像示意图，左右相机拍摄的图案编程了解码值

接下来需要在这对数据上计算视差，而确定相同编码值需要大量的遍历，对相同编码进一步的优化还要对每个点进行小范围的插值处理，时间复杂度很大。

视差图效果

1. 使用for训练的方式

使用for循环，需要3层。经测试后，在TX2上，使用c++来完成大概需要7s多。

2. 使用numpy的矩阵操作来实现

代码如下，使用numpy的广播的原理来实现，然后通过一系列的过滤异常值后，再经过插值进一步的处理得到最终想要的结果。
这段代码没有进一步的去实现插值的过程，耗时情况为1.35s。

1def disp(l_, r_, colstartR, colendR, colstartL, colendL, rowstart, rowend):
2    # 聚焦在有效值区域
3    l = l_[rowstart: rowend, colstartL: colendL]
4    r = r_[rowstart: rowend, colstartR: colendR]
5    # 算一下阈值。阈值帮助确定判断太远的点就不能当作是目标值
6    thres = (np.max(l) - np.min(l)) / (colendL - colstartL) * 10
7    h, w = l.shape
8    ll = l.T.reshape(w, h, 1)
9    # print(l.shape, r.shape)
10    # 加快运算，缩小图片，4倍下采样
11    quart_r = cv2.resize(r, (w // 4, h))
12    # 计算距离
13    distance = np.abs(ll - quart_r)
14    # 计算点位
15    idx_old = np.argmin(distance, axis=-1).T * 4
16    # 去除指向同一个点的重复值
17    _, d2 = np.unique(idx_old, return_index=True)
18    idx = np.zeros_like(idx_old).reshape(-1)
19    idx[d2] = idx_old.reshape(-1)[d2]
20    idx = idx.reshape(idx_old.shape)
21    # 计算最值
22    minV = np.min(distance, axis=-1).T
23    ori_idx = np.tile(np.arange(w).reshape(w, 1), h).T
24    disparity = ori_idx - idx + colstartL - colstartR
25    # 去除异常点
26    disparity[minV > thres] = 0# 大于阈值的
27    disparity[l < 1e-3] = 0 # 左图点无效的
28    # 插值
29    # 方法：在最值附近的区域去-5：5的值，二次线性插值上采样，采完之后再计算一遍上面的步骤，算完之后取小数进行计算
30    # 暂时没有实现这一步
31    return disparity, l, r
32

3. 使用julia-cuda实现

这段主要是cuda核函数的部分，主要包括以下部分：

1）用到了512*700个cuda线程来实现，增加的并行计算抵消了单个点位计算耗时。

2）还用到了共享显存，降低读取数据的耗时，因为右图中的每一行都会被左图中的同行中的每一个元素加载一遍，对于元素for循环是840*840的时间空间复杂度。这儿加载一遍，就可以让这些线程同时看到了。

3）对于上述过程中提到的插值一事，使用cuda的纹理内容轻松搞定，因为纹理内存的一个特性就是插值。即对于一个向量，可以取得到下标不是整数时的值，这些值就是自动插值出现的，且此过程的资源消耗非常低，因为这部分的初始设计是为了图像渲染和可视化。

4）通过这部分代码，实现相同的效果在TX2上的耗时是165ms，快了近10倍。

1function bench_match_smem(cfg, phaL, phaR, w, h, winSize, pha_dif)
2    texarr2D = CuTextureArray(phaR)
3    tex2D = CuTexture(texarr2D; interpolation = CUDA.LinearInterpolation())
4    cp, minv, maxv = cfg.cpdiff, cfg.minv, cfg.maxv
5    colstart, colend = cfg.colstart, cfg.colend
6    rowstart, rowend = cfg.rowstart, cfg.rowend
7    mindis, maxdis = cfg.mindis, cfg.maxdis
8    col_ = cld((colend - colstart), 32) * 32
9    row_ = cld(rowend - rowstart, 32) * 32 
10    stride = Int(cld((maxv - minv + 1), 512))
11    threadsPerBlock = round(Int32, cld((maxv - minv + 1) / stride, 32) * 32)
12    blocksPerGrid = row_
13    println("blocks = $blocksPerGrid threads = $threadsPerBlock left  $(col_) right $(maxv - minv) h=$(row_)")
14    @cuda  blocks = blocksPerGrid threads = threadsPerBlock shmem =
15        (threadsPerBlock * sizeof(Float32))  phaseMatch_smem!(cp, mindis, maxdis, minv, maxv, colstart, colend, rowstart, rowend, phaL, tex2D, threadsPerBlock,blocksPerGrid,stride, w, h, winSize, pha_dif)
16    CUDA.synchronize()
17    return
18end
19 
20#进行立体相位匹配
21function phaseMatch_smem!(cp, mindis, maxdis, minv, maxv, colstart, colend, rowstart, rowend, phaL, phaR, threadsPerBlock, blocksPerGrid, stride, w, h, winSize, pha_dif)
22    #---------------------------------------------------
23    # cp: diparity map
24    # mindis, maxdis 最近最远视差
25    #minv, maxv 仿射变换计算得到的R图中有效横向范围
26    # colstart, colend, rowstart, rowend仿射变换计算得到的左图中有效横向、竖向范围
27    #phaL, phaR 左右图像
28    #w, h图像大小
29    #winSize, pha_dif 3*3的框； 阈值：约等于20个像素的平均相位距离和
30    # Set up shared memory cache for this current block.
31    #--------------------------------------------------- 
32    wh = fld(winSize, 2)
33    cache = @cuDynamicSharedMem(Float32, threadsPerBlock)
34    left_stride = 64 
35    minv = max(1,minv)#必须是有效值，且是julia下的下标计数方式
36    colstart= max(1,wh*stride)
37    # 数据读入共享内存
38    j = blockIdx().x + rowstart  # 共用的行序号
39    i = threadIdx().x + colstart# 左图的列序号
40
41    while(j <= min(rowend,h - wh)) 
42        #数据拷贝到共享内存中去，并将由threadsPerBlock共享
43        ri = (threadIdx().x - 1) * stride + minv
44        tid = threadIdx().x
45        while(tid <= threadsPerBlock && ri <= maxv)
46            cache[tid] = phaR[j, ri] 
47            tid+=threadsPerBlock
48            ri+=threadsPerBlock
49        end
50        # synchronise threads
51        sync_threads()
52        maxv = min(fld(maxv - minv,stride) * stride + minv,maxv)
53        # 计算最小匹配项 
54        while(i <= min(colend,w - (wh*stride))) 
55            min_v = 10000
56            XR = -1
57            VV = phaL[j, i]
58            if(VV > 0.001f0)
59                kStart = max(minv, i - maxdis) + 1
60                kEnd = min(maxv, i - mindis) - 1
61                for k = kStart:kEnd  #遍历一整行
62                    RK = cache[cld(k - minv + 1,stride)]#从0开始计数
63                    if RK <= 0.001f0
64                        continue
65                    end
66                    dif = abs(VV - RK)
67                    if dif < pha_dif
68                        sum = 0.0f0
69                        sn = 1 
70                        for ki in 0:(winSize - 1) 
71                            R_local = cache[cld(k - minv + 1 - wh + ki,stride)]
72                            (R_local < 1e-5) && continue
73                            #phaL[j + kj - wh, i + ki - wh*stride]
74                            VR = VV - R_local
75                            sum = sum + abs(VR)# * VR
76                            sn += 1
77                        end 
78                        v = sum / sn
79                        if v < min_v
80                            min_v = v
81                            XR = k
82                        end
83                    end
84                end 
85                #需要作插值
86                #https://discourse.julialang.org/t/base-function-in-cuda-kernels/21866
87                if XR > 0
88                    XR_new = bisection(VV, phaR, Float32(j), Float32(XR - 3), Float32(XR + 3))
89                    # 注意，这里直接做了视差处理了
90                    state = (i - XR_new) > 0
91                    @inbounds cp[j, i] = state ? (i - XR_new) : 0.0f0
92                end
93            end 
94            i+=threadsPerBlock
95        end
96        j+=blocksPerGrid
97    end
98    sync_threads()
99    return
100end
101

4. 使用金字塔原理再次加速

1）这部分和上述代码的区别是，没有让少于列数目的线程进行多次运算，(上述代码中有个自增操作，是让线程进行了多次运算，原因是可分配线程总数不够)

2）整体是金字塔模式，即相邻者相似的原理。

3）时间消耗在TX2上降低到了72ms，相比于前一种方法又有了58%的降幅。

1#进行立体相位匹配
2function phaseMatch_smem!(cp, mindis, maxdis,
3    minv, maxv, colstart, colend,
4    rowstart, rowend, phaL, phaR,
5    threadsPerBlock, blocksPerGrid, stride,
6     w, h, winSize, pha_dif)
7    #---------------------------------------------------
8    # cp: diparity map
9    # mindis, maxdis 最近最远视差
10    #minv, maxv 仿射变换计算得到的R图中有效横向范围
11    # colstart, colend, rowstart, rowend仿射变换计算得到的左图中有效横向、竖向范围
12    #phaL, phaR 左右图像
13    #w, h图像大小
14    #winSize, pha_dif 3*3的框； 阈值：约等于20个像素的平均相位距离和
15    # Set up shared memory cache for this current block.
16    #--------------------------------------------------- 
17    wh = fld(winSize, 2)
18    cache = @cuDynamicSharedMem(Float32, threadsPerBlock) 
19    minv = max(1,minv)#必须是有效值，且是julia下的下标计数方式
20    colstart = max(1, colstart, wh*stride)
21    rowstart = max(1, rowstart, wh)#需要算3*3的矩阵，目前没有计算，所以不用严格满足>wh
22    # i 最大、最小区间，所需要的迭代次数，或者可以看成所需处理的步长
23    left_stride = Int(cld(colend - colstart, threadsPerBlock))
24    j = (blockIdx().x - 1) + rowstart  # 共用的行序号
25    i = (threadIdx().x - 1) * left_stride + colstart# 左图的列序号
26
27    while(j <= min(rowend,h - wh))
28        #数据拷贝到共享内存中去，并将由threadsPerBlock共享
29        ri = (threadIdx().x - 1) * stride + minv
30        tid = threadIdx().x
31        while(tid <= threadsPerBlock && ri <= maxv)
32            cache[tid] = phaR[j, ri] 
33            tid+=threadsPerBlock
34            ri+=threadsPerBlock
35        end
36        # synchronise threads
37        sync_threads()
38        maxv = min(fld(maxv - minv,stride) * stride + minv,maxv)
39        # 计算最小匹配项
40        #end_i = i + left_stride
41        #while(i <= min(colend, w - (wh*stride))) #end_i - 1,
42        if(i <= min(colend, w - (wh*stride))) #end_i - 1,
43            min_v = 10000
44            XR = -1
45            VV = phaL[j, i]
46            if(VV > 0.001f0)
47                kStart = max(minv, i - maxdis)
48                kEnd = min(maxv, i - mindis)
49                for k = kStart:kEnd  #遍历一整行
50                    RK = cache[cld(k - minv + 1,stride)]#从0开始计数
51                    if RK <= 0.001f0
52                        continue
53                    end
54                    dif = abs(VV - RK)
55                    if dif < pha_dif
56                        sum = 0.0f0
57                        sn = 1 
58                        for ki in 0:(winSize - 1) 
59                            R_local = cache[cld(k - minv + 1 - wh + ki,stride)]
60                            (R_local < 1e-5) && continue
61                            #phaL[j + kj - wh, i + ki - wh*stride]
62                            VR = VV - R_local
63                            sum = sum + abs(VR)# * VR
64                            sn += 1
65                        end 
66                        #v = sqrt(sum)/ sn
67                        v = sum / sn
68                        if v < min_v
69                            min_v = v
70                            XR = k
71                        end
72                    end
73                end
74
75                #需要作插值
76                #https://discourse.julialang.org/t/base-function-in-cuda-kernels/21866
77                if XR > 0
78                    for offset in 0:left_stride - 1
79                        i += offset
80                        VV = phaL[j, i]
81                        XR_new = bisection(VV, phaR, Float32(j), Float32(XR - 3), Float32(XR + 3))
82                        # 注意，这里直接做了视差处理了
83                        state = (i - XR_new) > 0
84                        @inbounds cp[j, i] = state ? (i - XR_new) : 0.0f0
85                    end
86                end
87            end
88        end
89        j+=blocksPerGrid
90    end
91    sync_threads()
92    return
93end
94

四、总结

julia作为一个交互性强的语言，在上述目的的达成上，它至少是做到了。对于上述算是一个标准的cuda加速过程，用cuda-c进行编写的话，也是类似的过程，典型操作。但是c++编写的可视化、调试、最终的编译要麻烦的多得多得多。julia达到高效率的目的的同时，让编写的过程没有那么痛苦，堪称完美的一次体验。

用于双目重建中的 GPU 编程：julia-cuda