Method forward

networks/mvsnet.py:188–260

:param is_flip: augment only for 3D-UNet :param imgs: (b, nview, c, h, w) :param proj_matrices: :param depth_values: :return:

(self, imgs, proj_matrices, depth_values)

        self.DepthNet = DepthNet(depth_mode)

    def forward(self, imgs, proj_matrices, depth_values):
        """
        :param is_flip: augment only for 3D-UNet
        :param imgs: (b, nview, c, h, w)
        :param proj_matrices:
        :param depth_values:
        :return:
        """
        depth_interval = (depth_values[0, -1] - depth_values[0, 0]) / depth_values.size(1)

        # step 1. feature extraction
        features = []
        for nview_idx in range(imgs.size(1)):  # imgs shape (B, N, C, H, W)
            img = imgs[:, nview_idx]
            features.append(self.feature(img))

        ori_shape = imgs[:, 0].shape[2:]  # (H, W)

        outputs = {}
        last_depth = None
        for stage_idx in range(self.num_stage):
            # print("*********************stage{}*********************".format(stage_idx + 1))
            # stage feature, proj_mats, scales
            features_stage = [feat["stage{}".format(stage_idx + 1)] for feat in features]
            proj_matrices_stage = proj_matrices["stage{}".format(stage_idx + 1)]
            # stage1: 1/4, stage2: 1/2, stage3: 1
            stage_scale = 2 ** (3 - stage_idx - 1)

            stage_shape = [ori_shape[0] // int(stage_scale), ori_shape[1] // int(stage_scale)]

            if stage_idx == 0:
                last_depth = depth_values
            else:
                last_depth = last_depth.detach()

            # (B, D, H, W)
            depth_range_samples, interval = get_depth_range_samples(last_depth=last_depth,
                                                                    ndepth=self.ndepths[stage_idx],
                                                                    depth_inteval_pixel=self.depth_interval_ratio[
                                                                                            stage_idx] * depth_interval,
                                                                    shape=stage_shape,  # only for first stage
                                                                    inverse=self.inverse_depth
                                                                    )

            if stage_idx > 0:
                depth_range_samples = F.interpolate(depth_range_samples, stage_shape, mode='bilinear', align_corners=Align_Corners_Range)

            # (b, c, d, h, w)
            cost_volume = self.cost_aggregation(features_stage, proj_matrices_stage, depth_range_samples, stage_idx)
            # cost volume regularization
            # (b, 1, d, h, w)
            cost_reg = self.cost_regularization[stage_idx](cost_volume)

            # depth
            outputs_stage = self.DepthNet(cost_reg, depth_range_samples, num_depth=self.ndepths[stage_idx], interval=interval,stage=stage_idx)