Depth-Anything推理详解及摆设实现（下）

前言

   在 Depth-Anything推理详解及摆设实现（上） 文章中我们有提到如何导出 Depth Anything 的 ONNX 模型，这篇文章就来看看如何在 tensorRT 上推理得到结果
  Note：开始之前大家需要参考 Depth-Anything推理详解及摆设实现（上） 将对应的环境配置好，并将 Depth Anything 的 ONNX 导出来，这里博主就不再介绍了
  repo：https://github.com/Melody-Zhou/tensorRT_Pro-YOLOv8
  reference：https://github.com/spacewalk01/depth-anything-tensorrt
    Depth-Anything-V1  

   Depth-Anything-V2  

一、Depth Anything推理(Python)

1. Depth Anything猜测

   我们先尝试使用官方预训练权重来推理一张图片并生存，看可否成功（以 V2 版本为主）
  将下载好的预训练权重放在 Depth-Anything-V2/checkpoints 项目下，准备开始推理，实行如下指令即可进行推理：

1. python run.py --encoder vitl --img-path assets/examples --outdir depth_vis

复制代码

可以看到推理成功了，结果生存在 depth_vis 文件夹下，如下图所示：

2. Depth Anything预处理

   模型推理成功后我们就要来梳理下 Depth Anything 的预处理和后处理，方便后续在 C++ 上实现，我们先看预处理的实现。
  我们来调试 run.py 文件：

博主这里接纳的是 vscode 进行代码的调试，此中的 launch.json 文件内容如下：

1. {
2.     // 使用 IntelliSense 了解相关属性。
3.     // 悬停以查看现有属性的描述。
4.     // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
5.     "version": "0.2.0",
6.     "configurations": [
7.         {
8.             "name": "Python: Current File",
9.             "type": "python",
10.             "request": "launch",
11.             "args": [
12.                 "--encoder", "vitl",
13.                 "--img-path", "assets/examples",
14.                 "--outdir", "depth_vis"
15.             ],
16.             "program": "${file}",
17.             "console": "integratedTerminal",
18.             "justMyCode": true
19.         }
20.     ]
21. }

复制代码

可以清晰的看到代码中首先通过 opencv 读取了一张图像，然后通过 DepthAnythingV2 类的 infer_image 方法推理，我们进入该函数看下内部具体的实现：

可以看到代码结构非常清晰，通过 self.image2tensor 做预处理，然后 forward 前向传播推理得到结果，接着插值规复到原图，最后将结果返回
我们这里主要分析的是预处理，所以重点看 self.image2tensor 函数内部的实现即可

整个预处理函数内容如上图所示，非常清晰，此中的 Resize、NormalizeImage 以及 PrepareForNet 操纵我们可以在 depth_anything_v2/util/transform.py 文件中找到相干的实现：

1. import numpy as np
2. import cv2
5. class Resize(object):
6.     """Resize sample to given size (width, height).
7.     """
9.     def __init__(
10.         self,
11.         width,
12.         height,
13.         resize_target=True,
14.         keep_aspect_ratio=False,
15.         ensure_multiple_of=1,
16.         resize_method="lower_bound",
17.         image_interpolation_method=cv2.INTER_AREA,
18.     ):
19.         """Init.
21.         Args:
22.             width (int): desired output width
23.             height (int): desired output height
24.             resize_target (bool, optional):
25.                 True: Resize the full sample (image, mask, target).
26.                 False: Resize image only.
27.                 Defaults to True.
28.             keep_aspect_ratio (bool, optional):
29.                 True: Keep the aspect ratio of the input sample.
30.                 Output sample might not have the given width and height, and
31.                 resize behaviour depends on the parameter 'resize_method'.
32.                 Defaults to False.
33.             ensure_multiple_of (int, optional):
34.                 Output width and height is constrained to be multiple of this parameter.
35.                 Defaults to 1.
36.             resize_method (str, optional):
37.                 "lower_bound": Output will be at least as large as the given size.
38.                 "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
39.                 "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
40.                 Defaults to "lower_bound".
41.         """
42.         self.__width = width
43.         self.__height = height
45.         self.__resize_target = resize_target
46.         self.__keep_aspect_ratio = keep_aspect_ratio
47.         self.__multiple_of = ensure_multiple_of
48.         self.__resize_method = resize_method
49.         self.__image_interpolation_method = image_interpolation_method
51.     def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
52.         y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
54.         if max_val is not None and y > max_val:
55.             y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int)
57.         if y < min_val:
58.             y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int)
60.         return y
62.     def get_size(self, width, height):
63.         # determine new height and width
64.         scale_height = self.__height / height
65.         scale_width = self.__width / width
67.         if self.__keep_aspect_ratio:
68.             if self.__resize_method == "lower_bound":
69.                 # scale such that output size is lower bound
70.                 if scale_width > scale_height:
71.                     # fit width
72.                     scale_height = scale_width
73.                 else:
74.                     # fit height
75.                     scale_width = scale_height
76.             elif self.__resize_method == "upper_bound":
77.                 # scale such that output size is upper bound
78.                 if scale_width < scale_height:
79.                     # fit width
80.                     scale_height = scale_width
81.                 else:
82.                     # fit height
83.                     scale_width = scale_height
84.             elif self.__resize_method == "minimal":
85.                 # scale as least as possbile
86.                 if abs(1 - scale_width) < abs(1 - scale_height):
87.                     # fit width
88.                     scale_height = scale_width
89.                 else:
90.                     # fit height
91.                     scale_width = scale_height
92.             else:
93.                 raise ValueError(f"resize_method {self.__resize_method} not implemented")
95.         if self.__resize_method == "lower_bound":
96.             new_height = self.constrain_to_multiple_of(scale_height * height, min_val=self.__height)
97.             new_width = self.constrain_to_multiple_of(scale_width * width, min_val=self.__width)
98.         elif self.__resize_method == "upper_bound":
99.             new_height = self.constrain_to_multiple_of(scale_height * height, max_val=self.__height)
100.             new_width = self.constrain_to_multiple_of(scale_width * width, max_val=self.__width)
101.         elif self.__resize_method == "minimal":
102.             new_height = self.constrain_to_multiple_of(scale_height * height)
103.             new_width = self.constrain_to_multiple_of(scale_width * width)
104.         else:
105.             raise ValueError(f"resize_method {self.__resize_method} not implemented")
107.         return (new_width, new_height)
109.     def __call__(self, sample):
110.         width, height = self.get_size(sample["image"].shape[1], sample["image"].shape[0])
111.         
112.         # resize sample
113.         sample["image"] = cv2.resize(sample["image"], (width, height), interpolation=self.__image_interpolation_method)
115.         if self.__resize_target:
116.             if "depth" in sample:
117.                 sample["depth"] = cv2.resize(sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST)
118.                
119.             if "mask" in sample:
120.                 sample["mask"] = cv2.resize(sample["mask"].astype(np.float32), (width, height), interpolation=cv2.INTER_NEAREST)
121.         
122.         return sample
125. class NormalizeImage(object):
126.     """Normlize image by given mean and std.
127.     """
129.     def __init__(self, mean, std):
130.         self.__mean = mean
131.         self.__std = std
133.     def __call__(self, sample):
134.         sample["image"] = (sample["image"] - self.__mean) / self.__std
136.         return sample
139. class PrepareForNet(object):
140.     """Prepare sample for usage as network input.
141.     """
143.     def __init__(self):
144.         pass
146.     def __call__(self, sample):
147.         image = np.transpose(sample["image"], (2, 0, 1))
148.         sample["image"] = np.ascontiguousarray(image).astype(np.float32)
150.         if "depth" in sample:
151.             depth = sample["depth"].astype(np.float32)
152.             sample["depth"] = np.ascontiguousarray(depth)
153.         
154.         if "mask" in sample:
155.             sample["mask"] = sample["mask"].astype(np.float32)
156.             sample["mask"] = np.ascontiguousarray(sample["mask"])
157.         
158.         return sample

复制代码

我们总结下 Depth Anything 预处理包罗以下步骤：

• cv2.cvtColor：BGR2RGB
  
• /255.0：除以 255，归一化
  
• Resize：将图像缩放到一定尺寸
  
  
  
  • 默认是 lower_bound 模式，保持长宽比的情况下，选择较大的缩放比例
    
  • 假设输入图像是 1920x1080，目标巨细是 518x518，lower_bound 模式下最终缩放的图像尺寸是 921x518
    
  • 更多细节可以查看相干代码：depth_anything_v2/util/transform.py#L68
    
  
  
• NormalizeImage：减均值除以标准差
  
• PrepareForNet：维度变更，HWC->CHW
  
• unsqueeze：添加 batch 维度，CHW->BCHW
  

因此我们不难写出对应的预处理代码，如下所示：

1. def constrain_to_multiple_of(x, min_val=0, max_val=None, multiple_of=14):
2.     y = (np.round(x / multiple_of) * multiple_of).astype(int)
4.     if max_val is not None and y > max_val:
5.         y = (np.floor(x / multiple_of) * multiple_of).astype(int)
7.     if y < min_val:
8.         y = (np.ceil(x / multiple_of) * multiple_of).astype(int)
10.     return y
12. def preprocess(img, dst_width=518, dst_height=518):
13.     # 0. BGR2RGB
14.     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
16.     # 1. /255.0
17.     img = (img / 255.0).astype(np.float32)
19.     # 2. resize (lower_bound mode)
20.     height = img.shape[0]
21.     width  = img.shape[1]
22.     scale_height = dst_height / height
23.     scale_width  = dst_width / width
24.     if scale_width > scale_height:
25.         scale_height = scale_width
26.     else:
27.         scale_width = scale_height
28.     new_height = constrain_to_multiple_of(scale_height * height, min_val=dst_height)
29.     new_width  = constrain_to_multiple_of(scale_width * width, min_val=dst_width)
30.     img = cv2.resize(img, (new_width, new_height), interpolation=2)
31.    
32.     # 3. normalize
33.     mean = [0.485, 0.456, 0.406]
34.     std  = [0.229, 0.224, 0.225]
35.     mean = np.array(mean).reshape(1, 1, 3).astype("float32")
36.     std  = np.array(std).reshape(1, 1, 3).astype("float32")
37.     img  = (img - mean) / std
39.     # 4. to bchw
40.     img = img.transpose(2, 0, 1)[None]
41.     img = torch.from_numpy(img)
43.     return img

复制代码

3. Depth Anything后处理

   我们再来看看后处理的实现
  后处理的代码在 infer_image 方法中就有实现，如下所示：

它包罗以下步骤：

• F.interpolate：插值
  

后处理的实现非常简朴，因为本来模型输出的就是一张深度图，我们只需要做双线性插值将它缩放回原图巨细即可
因此我们不难写出对应的后处理代码，如下所示：

1. def postprocess(depth, origin_w, origin_h):
2.     # depth->1x1x518x518
3.     depth = F.interpolate(depth[:, None], (origin_h, origin_w), mode="bilinear", align_corners=True)[0, 0]
4.     return depth.cpu().numpy()

复制代码

4. Depth Anything推理

   通过上面对 Depth Anything 的预处理和后处理分析之后，整个推理过程就显而易见了。Depth Anything 的推理包罗图像预处理、模型推理、猜测结构后处理三部门，此中预处理主要包罗 resize、normalize 等操纵，后处理主要包罗 interpolate 操纵
  完备的推理代码如下：

1. import cv2import torchimport matplotlibimport numpy as npimport torch.nn.functional as Ffrom depth_anything_v2.dpt import DepthAnythingV2def constrain_to_multiple_of(x, min_val=0, max_val=None, multiple_of=14):
2.     y = (np.round(x / multiple_of) * multiple_of).astype(int)
4.     if max_val is not None and y > max_val:
5.         y = (np.floor(x / multiple_of) * multiple_of).astype(int)
7.     if y < min_val:
8.         y = (np.ceil(x / multiple_of) * multiple_of).astype(int)
10.     return y
12. def preprocess(img, dst_width=518, dst_height=518):
13.     # 0. BGR2RGB
14.     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
16.     # 1. /255.0
17.     img = (img / 255.0).astype(np.float32)
19.     # 2. resize (lower_bound mode)
20.     height = img.shape[0]
21.     width  = img.shape[1]
22.     scale_height = dst_height / height
23.     scale_width  = dst_width / width
24.     if scale_width > scale_height:
25.         scale_height = scale_width
26.     else:
27.         scale_width = scale_height
28.     new_height = constrain_to_multiple_of(scale_height * height, min_val=dst_height)
29.     new_width  = constrain_to_multiple_of(scale_width * width, min_val=dst_width)
30.     img = cv2.resize(img, (new_width, new_height), interpolation=2)
31.    
32.     # 3. normalize
33.     mean = [0.485, 0.456, 0.406]
34.     std  = [0.229, 0.224, 0.225]
35.     mean = np.array(mean).reshape(1, 1, 3).astype("float32")
36.     std  = np.array(std).reshape(1, 1, 3).astype("float32")
37.     img  = (img - mean) / std
39.     # 4. to bchw
40.     img = img.transpose(2, 0, 1)[None]
41.     img = torch.from_numpy(img)
43.     return img
44. def postprocess(depth, origin_w, origin_h):
45.     # depth->1x1x518x518
46.     depth = F.interpolate(depth[:, None], (origin_h, origin_w), mode="bilinear", align_corners=True)[0, 0]
47.     return depth.cpu().numpy()
48. def visualization(depth):    cmap  = matplotlib.colormaps.get_cmap('Spectral_r')    depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0    depth = depth.astype(np.uint8)    depth = (cmap(depth)[:, :, :3] * 255)[:, :, ::-1].astype(np.uint8)    return depthif __name__ == "__main__":    encoder = 'vitl'    chekpoint = f"checkpoints/depth_anything_v2_{encoder}.pth"    DEVICE  = 'cuda' if torch.cuda.is_available() else 'mps' if torch.backends.mps.is_available() else 'cpu'        model_configs = {        'vits': {'encoder': 'vits', 'features': 64, 'out_channels': [48, 96, 192, 384]},        'vitb': {'encoder': 'vitb', 'features': 128, 'out_channels': [96, 192, 384, 768]},        'vitl': {'encoder': 'vitl', 'features': 256, 'out_channels': [256, 512, 1024, 1024]},        'vitg': {'encoder': 'vitg', 'features': 384, 'out_channels': [1536, 1536, 1536, 1536]}    }    depth_anything = DepthAnythingV2(**model_configs[encoder])    depth_anything.load_state_dict(torch.load(chekpoint, map_location='cpu'))    depth_anything = depth_anything.to(DEVICE).eval()    raw_image = cv2.imread("assets/examples/demo16.jpg")    origin_h  = raw_image.shape[0]    origin_w  = raw_image.shape[1]    # 1. preprocess    image = preprocess(raw_image)    image = image.to(DEVICE)    # 2. infer    with torch.no_grad():        depth = depth_anything.forward(image)        # 3. postprocess    depth = postprocess(depth, origin_w, origin_h)    # 4. visualization    depth_image = visualization(depth)    split_region = np.ones((raw_image.shape[0], 50, 3), dtype=np.uint8) * 255    combined_result = cv2.hconcat([raw_image, split_region, depth_image])    cv2.imwrite("result.jpg", combined_result)    print("save done.")

复制代码

推理效果如下图：

至此，我们在 Python 上面完成了 Depth Anything 的整个推理过程，下面我们去 C++ 上实现
二、Depth Anything推理(C++)

   C++ 上的实现我们使用的 repo 依旧是 tensorRT_Pro，博主在摆设过程中主要参考的是 depth-anything-tensorrt 这个 repo，如今我们就基于 tensorRT_Pro 完成 Depth Anything 在 C++ 上的推理
  1. ONNX导出

ONNX 导出的细节请参考 Depth-Anything推理详解及摆设实现（上），这边博主不再赘述
2. Depth Anything预处理

   之前有提到 Depth Anything 的预处理就是 resize 操纵，但并不是直接 resize 到 518x518 而是接纳的 lower_bound mode，这意味着每次 resize 的尺寸不同等，需要考虑动态宽高，但博主并不太想让模型的宽高动态，这边先鉴戒下 depth-anything-tensorrt 看这个 repo 的预处理是如何实现的
  depth-anything-tensorrt 这个 repo 中预处理的代码非常清晰，主要在 utils.cpp 文件中，如下图所示：

通过 resize_depth 即可完成 C++ 上 Depth Anything 的预处理操纵，此中的 cv::Mat result 变量并没有使用到，而且总感觉逻辑有些希奇
另外经过博主的分析貌似 resize_depth 函数做了两次 resize，第一次是保持宽高比 resize，第二次是直接 resize 到目标宽高（518x518），这个博主也没太看懂是什么意思
博主这边的预处理操纵计划将原图直接 resize 到 518x518，值得注意的是在 tensorRT_Pro 中有提供现成的 CUDA 核函数来实现 resize，我们拿过来直接使用即可
预处理代码如下：

1. // same to opencv
2. // reference: https://github.com/opencv/opencv/blob/24fcb7f8131f707717a9f1871b17d95e7cf519ee/modules/imgproc/src/resize.cpp
3. // reference: https://github.com/openppl-public/ppl.cv/blob/04ef4ca48262601b99f1bb918dcd005311f331da/src/ppl/cv/cuda/resize.cu
4. /*
5.         可以考虑用同样实现的resize函数进行训练，python代码在：tools/test_resize.py
6. */
7. __global__ void resize_bilinear_and_normalize_kernel(
8.         uint8_t* src, int src_line_size, int src_width, int src_height, float* dst, int dst_width, int dst_height,
9.         float sx, float sy, Norm norm, int edge
10. ){
11.         int position = blockDim.x * blockIdx.x + threadIdx.x;
12.         if (position >= edge) return;
14.         int dx      = position % dst_width;
15.         int dy      = position / dst_width;
16.         float src_x = (dx + 0.5f) * sx - 0.5f;
17.         float src_y = (dy + 0.5f) * sy - 0.5f;
18.         float c0, c1, c2;
20.         int y_low = floorf(src_y);
21.         int x_low = floorf(src_x);
22.         int y_high = limit(y_low + 1, 0, src_height - 1);
23.         int x_high = limit(x_low + 1, 0, src_width - 1);
24.         y_low = limit(y_low, 0, src_height - 1);
25.         x_low = limit(x_low, 0, src_width - 1);
27.         int ly    = rint((src_y - y_low) * INTER_RESIZE_COEF_SCALE);
28.         int lx    = rint((src_x - x_low) * INTER_RESIZE_COEF_SCALE);
29.         int hy    = INTER_RESIZE_COEF_SCALE - ly;
30.         int hx    = INTER_RESIZE_COEF_SCALE - lx;
31.         int w1    = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx;
32.         float* pdst = dst + dy * dst_width + dx * 3;
33.         uint8_t* v1 = src + y_low * src_line_size + x_low * 3;
34.         uint8_t* v2 = src + y_low * src_line_size + x_high * 3;
35.         uint8_t* v3 = src + y_high * src_line_size + x_low * 3;
36.         uint8_t* v4 = src + y_high * src_line_size + x_high * 3;
38.         c0 = resize_cast(w1 * v1[0] + w2 * v2[0] + w3 * v3[0] + w4 * v4[0]);
39.         c1 = resize_cast(w1 * v1[1] + w2 * v2[1] + w3 * v3[1] + w4 * v4[1]);
40.         c2 = resize_cast(w1 * v1[2] + w2 * v2[2] + w3 * v3[2] + w4 * v4[2]);
42.         if(norm.channel_type == ChannelType::Invert){
43.                 float t = c2;
44.                 c2 = c0;  c0 = t;
45.         }
47.         if(norm.type == NormType::MeanStd){
48.                 c0 = (c0 * norm.alpha - norm.mean[0]) / norm.std[0];
49.                 c1 = (c1 * norm.alpha - norm.mean[1]) / norm.std[1];
50.                 c2 = (c2 * norm.alpha - norm.mean[2]) / norm.std[2];
51.         }else if(norm.type == NormType::AlphaBeta){
52.                 c0 = c0 * norm.alpha + norm.beta;
53.                 c1 = c1 * norm.alpha + norm.beta;
54.                 c2 = c2 * norm.alpha + norm.beta;
55.         }
57.         int area = dst_width * dst_height;
58.         float* pdst_c0 = dst + dy * dst_width + dx;
59.         float* pdst_c1 = pdst_c0 + area;
60.         float* pdst_c2 = pdst_c1 + area;
61.         *pdst_c0 = c0;
62.         *pdst_c1 = c1;
63.         *pdst_c2 = c2;
64. }
66. void resize_bilinear_and_normalize(
67.         uint8_t* src, int src_line_size, int src_width, int src_height, float* dst, int dst_width, int dst_height,
68.         const Norm& norm,
69.         cudaStream_t stream) {
70.        
71.         int jobs   = dst_width * dst_height;
72.         auto grid  = CUDATools::grid_dims(jobs);
73.         auto block = CUDATools::block_dims(jobs);
74.        
75.         checkCudaKernel(resize_bilinear_and_normalize_kernel << <grid, block, 0, stream >> > (
76.                 src, src_line_size,
77.                 src_width, src_height, dst,
78.                 dst_width, dst_height, src_width/(float)dst_width, src_height/(float)dst_height, norm, jobs
79.         ));
80. }

复制代码

此中 ChannelType 需要指定为 Invert 即实行 BGR2RGB 这个操纵，NormType 需要指定为 MeanStd 即实行减均值除标准差这个操纵
关于预处理部门其实就是调用了上述 CUDA 核函数来实现 resize，由于在 CUDA 中我们是对每个像素进行操纵，因此非常容易实现 BGR2RGB，/255.0 等操纵
3. Depth Anything后处理

   之前我们有提到 Depth Anything 的后处理非常简朴，对模型输出的深度图做一个插值即可
  我们接着看下 depth-anything-tensorrt 这个 repo 中后处理是如何做的，具体的代码主要在 depth_anything.cpp 文件中，如下图所示：

包罗以下操纵：(from ChatGPT)

• cudaMemcpyAsync：将模型推理结果从 GPU 拷贝回 CPU，存储在 depth_data 变量中
  
• cv::Mat depth_map：将 depth_data 转换为 opencv 的 Mat 对象，方便后续处理
  
• cv::normalize：将深度图数据归一化到 0~255 范围
  
• cv::applyColorMap：将深度数据转换为伪彩色图像，增加可视性
  
• cv::resize：将天生的彩色深度图像 colormap 调解到原始输入图像尺寸
  

那实际任务中我们只需要知道每个像素的深度估计值就行，也就是得到 depth_map 然后 resize 缩放到原图尺寸就行，至于后续的只是为了方便可视化
因此我们不难写出后处理的代码：

1. if(interpolation_device_ == InterpolationDevice::CPU){
2.     for(int ibatch = 0; ibatch < infer_batch_size; ++ibatch){
3.         auto& job         = fetch_jobs[ibatch];
4.         auto& depth_image = job.output;
5.         float* parry  = output->cpu<float>(ibatch);
7.         cv::Mat depth_mat(input_height_, input_width_, CV_32FC1, parry);
8.         depth_image = depth_mat;
9.         job.pro->set_value(depth_image);
10.     }
11.     fetch_jobs.clear();
12. }

复制代码

在上述代码中我们首先将模型的输出数据从 GPU 拷贝回 CPU，然后转换为 cv::Mat 的格式并返回，至于 resize 操纵则是在外部实现的
当然我们也可以将模型输出的 518x518 的深度图直接通过 Kernel 核函数来做 resize，之后再拷贝回 CPU，在 tensorRT_Pro 中就有 resize 相干核函数的实现，我们简朴修改下即可，如下所示：

1. #define INTER_RESIZE_COEF_BITS 11
2. #define INTER_RESIZE_COEF_SCALE (1 << INTER_RESIZE_COEF_BITS)
4. template<typename _T>
5. static __inline__ __device__ _T limit(_T value, _T low, _T high){
6.     return value < low ? low : (value > high ? high : value);
7. }
9. __global__ void resize_bilinear_depth_kernel(
10.     float* src, int src_width, int src_height,
11.     float* dst, int dst_width, int dst_height,
12.     float sx, float sy, int edge
13. ){
14.     int position = blockDim.x * blockIdx.x + threadIdx.x;
15.     if (position >= edge) return;
17.     int dx      = position % dst_width;
18.     int dy      = position / dst_width;
19.     float src_x = (dx + 0.5f) * sx - 0.5f;
20.     float src_y = (dy + 0.5f) * sy - 0.5f;
22.     int y_low = floorf(src_y);
23.     int x_low = floorf(src_x);
24.     int y_high = limit(y_low + 1, 0, src_height - 1);
25.     int x_high = limit(x_low + 1, 0, src_width - 1);
26.     y_low = limit(y_low, 0, src_height - 1);
27.     x_low = limit(x_low, 0, src_width - 1);
29.     int ly = rint((src_y - y_low) * INTER_RESIZE_COEF_SCALE);
30.     int lx = rint((src_x - x_low) * INTER_RESIZE_COEF_SCALE);
31.     int hy = INTER_RESIZE_COEF_SCALE - ly;
32.     int hx = INTER_RESIZE_COEF_SCALE - lx;
33.     int w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx;
35.     float v1 = src[y_low * src_width + x_low];
36.     float v2 = src[y_low * src_width + x_high];
37.     float v3 = src[y_high * src_width + x_low];
38.     float v4 = src[y_high * src_width + x_high];
40.     float interpolated_value = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4) / INTER_RESIZE_COEF_SCALE;
41.     dst[dy * dst_width + dx] = interpolated_value;
42. }

复制代码

那么这么做存在着一些题目，我们背面再做说明
4. Depth Anything推理

   通过上面对 Depth Anything 的预处理和后处理分析之后，整个推理过程就显而易见了。C++ 上 Depth Anything 的预处理部门直接沿用 tensorRT_Pro 中的 resize 核函数，后处理部门将深度图缩放为原图尺寸即可
  我们在终端实行如下指令即可完成推理（注意！完备流程博主会在后续内容介绍，这边只是简朴演示）：

1. make depth_anything -j64

复制代码

编译图解如下所示：

推理结果如下图所示：

至此，我们在 C++ 上面完成了 Depth Anything 的整个推理过程，下面我们将完备的走一遍流程
三、Depth Anything摆设

   博主新建了一个堆栈 tensorRT_Pro-YOLOv8，该堆栈基于 shouxieai/tensorRT_Pro，并进行了调解以支持 YOLOv8 的各项任务，如今已支持分类、检测、分割、姿态点估计任务。
  下面我们就来看看如何使用 tensorRT_Pro-YOLOv8 这个 repo 完成 Depth Anything 模型的推理。
  1. 源码下载

tensorRT_Pro-YOLOv8 的代码可以直接从 GitHub 官网上下载，源码下载地址是 https://github.com/Melody-Zhou/tensorRT_Pro-YOLOv8，Linux 下代码克隆指令如下：

1. git clone https://github.com/Melody-Zhou/tensorRT_Pro-YOLOv8.git

复制代码

也可手动点击下载，点击右上角的 Code 按键，将代码下载下来。至此整个项目就已经准备好了。也可以点击 here 下载博主准备好的源代码（注意代码下载于 2024-12-14 日，如有改动请参考最新）
2. 环境配置

   需要使用的软件环境有 TensorRT、CUDA、cuDNN、OpenCV、Protobuf，所有软件环境的安装可以参考 Ubuntu20.04软件安装大全，这里不再赘述，需要各位看官自行配置好相干环境