def build()

in mmf/models/mesh_renderer.py [0:0]

• 69 lines of code
• 13 McCabe index (conditional complexity)

    def build(self):
        self.batch_size = self.config.batch_size // get_world_size()
        self.image_size_H = self.config.image_size_H
        self.image_size_W = self.config.image_size_W
        if self.image_size_H != self.image_size_W:
            raise NotImplementedError()
        self.grid_stride = self.config.grid_stride
        if (self.image_size_H % self.grid_stride != 0
                or self.image_size_W % self.grid_stride != 0):
            raise Exception("image sizes must be divisible by grid_stride")
        self.grid_H = self.image_size_H // self.grid_stride + 1
        self.grid_W = self.image_size_W // self.grid_stride + 1

        # Offset and depth prediction
        self.offset_and_depth_predictor = OffsetAndZGridPredictor(
            grid_stride=self.grid_stride,
            grid_H=self.grid_H,
            grid_W=self.grid_W,
            z_min=self.config.z_min,
            z_max=self.config.z_max,
            pred_inv_z=self.config.pred_inv_z,
            pred_inv_z_synsin=self.config.pred_inv_z_synsin,
            z_pred_scaling=self.config.z_pred_scaling,
            z_pred_offset=self.config.z_pred_offset,
            backbone_name=self.config.backbone_name,
            backbone_dim=self.config.backbone_dim
        )
        if self.config.freeze_offset_and_depth_predictor:
            assert self.config.use_inpainting, \
                "freeze_offset_and_depth_predictor is intended for inpainter " \
                "training alone."
            for p in self.offset_and_depth_predictor.parameters():
                p.requires_grad = False

        self.novel_view_projector = NovelViewProjector(
            batch_size=self.batch_size,
            image_size_H=self.image_size_H,
            image_size_W=self.image_size_W,
            grid_H=self.grid_H,
            grid_W=self.grid_W,
            blur_radius=self.config.rendering.blur_radius,
            faces_per_pixel=self.config.rendering.faces_per_pixel,
            clip_barycentric_coords=self.config.rendering.clip_barycentric_coords,
            sigma=self.config.rendering.sigma,
            gamma=self.config.rendering.gamma,
            background_color=self.config.rendering.background_color,
            hfov=self.config.rendering.hfov,
            z_background=self.config.rendering.z_background,
            gblur_kernel_size=self.config.rendering.gblur_kernel_size,
            gblur_sigma=self.config.rendering.gblur_sigma,
            gblur_weight_thresh=self.config.rendering.gblur_weight_thresh,
            directly_use_img_as_texture=self.config.directly_use_img_as_texture
        )

        self.use_discriminator = False
        if self.config.use_inpainting:
            self.inpainting_net_G = MeshRGBGenerator(self.config.inpainting.net_G)
            if self.config.inpainting.use_discriminator:
                self.mesh_gan_losses = MeshGANLosses(self.config.inpainting.net_D)
                self.use_discriminator = True

        self.build_losses()
        self.build_metrics()

        if self.config.save_forward_results:
            os.makedirs(self.config.forward_results_dir, exist_ok=True)
            if self.config.save_for_external_inpainting:
                # save PNG image files for external inpainting training and eval
                self.inpainting_src_dir = os.path.join(
                    self.config.forward_results_dir, 'inpainting_src'
                )
                self.inpainting_tgt_dir = os.path.join(
                    self.config.forward_results_dir, 'inpainting_tgt'
                )
                os.makedirs(self.inpainting_src_dir, exist_ok=True)
                os.makedirs(self.inpainting_tgt_dir, exist_ok=True)