Function raw2outputs

script/models/rendering.py:67–130

Implementation of original NeRF seems like it is different with rendering implementation from nerf-w https://github.com/kwea123/nerf_pl/blob/nerfw/models/rendering.py Inputs: raw: torch.Tensor() [N_rays, N_samples, 4]

(raw, z_vals, rays_d, raw_noise_std=0, white_bkgd=False, pytest=False)

    return samples

def raw2outputs(raw, z_vals, rays_d, raw_noise_std=0, white_bkgd=False, pytest=False):
    '''
    Implementation of original NeRF
    seems like it is different with rendering implementation from nerf-w
    https://github.com/kwea123/nerf_pl/blob/nerfw/models/rendering.py
    Inputs:
        raw: torch.Tensor() [N_rays, N_samples, 4]
    '''

    # Function for computing density from model prediction. This value is
    # strictly between [0, 1].
    raw2alpha = lambda raw, dists, act_fn=F.relu: 1.-torch.exp(-act_fn(raw)*dists)
    
    # Compute 'distance' (in time) between each integration time along a ray.
    dists = z_vals[...,1:] - z_vals[...,:-1]

    # The 'distance' from the last integration time is infinity.
    dists = torch.cat([dists, torch.Tensor([1e10]).expand(dists[...,:1].shape)], -1)  # [N_rays, N_samples] the last delta is infinity (1e10)

    # Multiply each distance by the norm of its corresponding direction ray
    # to convert to real world distance (accounts for non-unit directions).
    dists = dists * torch.norm(rays_d[...,None,:], dim=-1) # why raw2outputs_NeRFW doesn't have this step?

    # Extract RGB of each sample position along each ray. (NeRFW sigmoided in network)
    rgb = torch.sigmoid(raw[...,:3])  # [N_rays, N_samples, 3]
    
    # Add noise to model's predictions for density. Can be used to 
    # regularize network during training (prevents floater artifacts).
    noise = 0.
    if raw_noise_std > 0.:
        noise = torch.randn(raw[...,3].shape) * raw_noise_std

        # Overwrite randomly sampled data if pytest
        if pytest:
            np.random.seed(0)
            noise = np.random.rand(*list(raw[...,3].shape)) * raw_noise_std
            noise = torch.Tensor(noise)

    # Predict density of each sample along each ray. Higher values imply
    # higher likelihood of being absorbed at this point.
    alpha = raw2alpha(raw[...,3] + noise, dists)  # [N_rays, N_samples]

    # Compute weight for RGB of each sample along each ray.  A cumprod() is
    # used to express the idea of the ray not having reflected up to this
    # sample yet.
    # weights = alpha * tf.math.cumprod(1.-alpha + 1e-10, -1, exclusive=True)
    weights = alpha * torch.cumprod(torch.cat([torch.ones((alpha.shape[0], 1)), 1.-alpha + 1e-10], -1), -1)[:, :-1]

    # Computed weighted color of each sample along each ray.
    rgb_map = torch.sum(weights[...,None] * rgb, -2)  # [N_rays, 3]

    # Estimated depth map is expected distance.
    depth_map = torch.sum(weights * z_vals, -1)

    # Disparity map is inverse depth.
    disp_map = 1./torch.max(1e-10 * torch.ones_like(depth_map), depth_map / torch.sum(weights, -1))
    
    # Sum of weights along each ray. This value is in [0, 1] up to numerical error.