Method forward

models/strand_codec.py:296–373

(self, strand_features, hyperparams, normalization_dict)

    def forward(self, strand_features, hyperparams, normalization_dict):
        nr_strands = strand_features.shape[0]
        strand_features = strand_features.view(nr_strands, 1, -1).repeat(1, self.nr_verts_to_create, 1) # nr_strands x 100 x nr_channels
        t = self.t.view(1, self.nr_verts_to_create, -1).repeat(nr_strands, 1, 1) #nrstrands, nr_verts, nr_channels
        

        point_indices = None
        if self.decode_random_verts:
            # choose a random t for each strand
            # we can create only up until the very last vertex, except the tip, we need to be able to sample the next vertex so as to get a direction vector
            probability = torch.ones([nr_strands, self.num_pts - 2], dtype=torch.float32, device=torch.device("cuda")) 
            point_indices = torch.multinomial(probability, self.nr_verts_to_create, replacement=False) # size of the chunk size we selected
            # add also the next vertex on the strand so that we can compute directions
            point_indices = torch.cat([point_indices, point_indices + 1], 1)

            t = batched_index_select(t, 1, point_indices)

        # decode xyz
        h_siren = t
        z_scaling = self.z_scaling
        z = strand_features
        z_initial = z * z_scaling
        z = z * z_scaling

        #cat also T
        z=torch.cat([z,t],dim=2)


        hair_dir=None
        for i in range(self.nr_layers):
            gain = self.gain_per_layer[i]
            
            h_modulation = self.activ( self.modulation_layers[i](z))
           
            s = self.siren_layers[i](h_siren)
          
            #the input to the siren has to be unit gaussian, if we multiply by hmodulation, we are reducing the variance by Zscaling, so we boost the variance back up with this so that h_siren is unit gaussian again
            h_siren = h_modulation * s * (1.0/(z_scaling*gain)) 
            
            z = torch.cat([z_initial, h_modulation,t], 2)
            


        pred_dict={}

        if self.decode_type=="xyz":
            points_pos = self.decode_val(h_siren)
            if self.decode_random_verts:
                pred_strands = points_pos
            else:
                # start_positions = torch.zeros(nr_strands, 1, 3).cuda()
                start_positions = self.start_positions.repeat(nr_strands,1,1)
                pred_strands = torch.cat([start_positions, points_pos], 1)
                #positions are normalized to be in unit gaussian so we denormalize them to be in real space
                pred_strands=un_normalize_data(pred_strands, normalization_dict["xyz_mean"], normalization_dict["xyz_std"])
        elif self.decode_type=="dir":
            # divide by the nr of points on the strand otherwise the direction will have norm=1 and then when integrated you end up with a gigantic strand that has 100 units