Fix: Revert render hack, apply SH ambient boost to keep background black

trellis/renderers/gaussian_render.py

@@ -116,7 +116,68 @@ def render(viewpoint_camera, pc : Gaussian, pipe, bg_color : torch.Tensor, scali
             sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized)
             colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0)
         else:
+            # 🔧 SHADOW WAR PIG FIX: Boost Ambient Light directly in SH coefficients
+            # The DC component (shs[:, 0, :]) represents ambient color/light.
+            # Boosting this makes the splats themselves brighter, without touching the background.
+            # 0.15 is a moderate boost to lift crushed shadows.
             shs = pc.get_features
+            
+            # Clone to avoid modifying the original model parameters in place (gradients etc)
+            # shs shape is [N, n_bands^2, 3] or [N, 3, n_bands^2] depending on implementation.
+            # Usually [Point_Count, 3, (Deg+1)^2] ? No, usually [N, (Deg+1)**2, 3] in some impls, 
+            # but here line 113 says: .transpose(1, 2).view(-1, 3, ...) implies storage is [N, Features, ...]
+            
+            # Let's just modify the SHs passed to the rasterizer.
+            # The rasterizer expects SHs.
+            # We want to add to the first coefficient (DC).
+            
+            # The structure of shs is typically [N, (max_sh_degree+1)**2 * 3] or similar.
+            # But line 113 suggests `pc.get_features` has dimensions that need transposing.
+            # Actually, looking at `gaussian_model.py` (standard), features are [N, C, n_bands].
+            
+            # SAFEST WAY: Add to the DC component which is usually the first 3 values if flattened, 
+            # or index 0 in the feature dimension.
+            
+            # Let's apply a "pre-rasterization lift" to the DC component.
+            # shs = pc.get_features  <-- This is likely a Tensor. 
+            # We need to add to it.
+            
+            # To avoid shape guessing hell, we will use a simpler approach if possible.
+            # However, `pc.get_features` returns the raw tensor.
+            # We can just add a scalar to the whole thing? No, that breaks directionality.
+            # We must only boost DC.
+            
+            shs = pc.get_features.clone()
+            
+            # Assume DC components are at the beginning.
+            # Standard Gaussian Splatting storage:
+            # f_dc: [N, 1, 3]
+            # f_rest: [N, 15, 3]
+            # get_features cats them -> [N, 16, 3] typically?
+            # Or [N, 48]?
+            
+            # Let's look at `eval_sh`: result = C0 * sh[..., 0]
+            # It expects sh to be [..., C, (deg+1)**2] ?
+            # line 65: sh coeffs [..., C, (deg + 1) ** 2]
+            # line 74: result = C0 * sh[..., 0] 
+            
+            # So index 0 is the DC component.
+            # Boosting sh[..., 0] effectively adds ambient light.
+            
+            # pc.get_features shape?
+            # If we look at line 113: `pc.get_features.transpose(1, 2)`
+            # This implies `pc.get_features` is [N, (deg+1)**2, 3].
+            # So index 0 of the second dimension is DC.
+            
+            # shs[:, 0, :] += 0.5 / C0 (to add 0.5 to final color)
+            # C0 = 0.282...
+            # To add 0.1 brightness: 0.1 / 0.282 ~= 0.354
+            
+            # SHADOW LIFT FACTOR
+            # User wants to fix dark shadows.
+            LIFT_AMOUNT = 0.5  # Boost DC coefficient
+            shs[:, 0, :] += LIFT_AMOUNT
+            
     else:
         colors_precomp = override_color
 

trellis/utils/render_utils.py

@@ -73,26 +73,7 @@ def render_frames(sample, extrinsics, intrinsics, options={}, colors_overwrite=N
             res = renderer.render(sample, extr, intr, colors_overwrite=colors_overwrite)
             if 'color' not in rets: rets['color'] = []
             if 'depth' not in rets: rets['depth'] = []
-            # 🔧 Apply Shadow Lift (on float data) based on user feedback
-            # Shadows from splats are often too dark/crushed. We lift them here on the high-precision float data.
-            color_tensor = res['color'].detach().cpu()
-            # Calculate luminance for mask
-            lum = 0.299 * color_tensor[0] + 0.587 * color_tensor[1] + 0.114 * color_tensor[2]
-            
-            # Shadow Threshold: 0.2 (Dark shadows)
-            # Lift Factor: 0.15 (Moderate lift)
-            shadow_mask = (lum < 0.2)
-            if shadow_mask.any():
-                # Quadratic lift: (1 - x/threshold)^2 scale
-                # This ensures x=0 gets max lift, x=threshold gets 0 lift. Smooth transition.
-                lift = 0.15 * torch.pow(1.0 - lum / 0.2, 2)
-                lift = lift * shadow_mask.float()
-                
-                # Apply lift to all channels
-                color_tensor = color_tensor + lift.unsqueeze(0)
-            
-            rets['color'].append(np.clip(color_tensor.numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8))
-            
+            rets['color'].append(np.clip(res['color'].detach().cpu().numpy().transpose(1, 2, 0) * 255, 0, 255).astype(np.uint8))
             if 'percent_depth' in res:
                 rets['depth'].append(res['percent_depth'].detach().cpu().numpy())
             elif 'depth' in res: