Read and unpack the next bytes from a binary file. :param fid: :param num_bytes: Sum of combination of {2, 4, 8}, e.g. 2, 6, 16, 30, etc. :pa

Write stdout text, appending a timestamp to completed lines.

Return training cameras for the requested resolution scale.

Read a JSON config or result file in one common way.

Remove Gaussians selected by `mask` and prune matching optimizer state.

Copy only this group's parsed fields from the shared argparse namespace.

Format a metric for JSON/CSV summaries, leaving missing values blank.

Create an all-false CUDA mask with one entry per current Gaussian.

Append newly created Gaussians to all parameter tensors. The optimizer receives the new tensors first, then the model fields

Convert focal length in pixels to field of view in radians.

Save the current point cloud and exposure table for one iteration.

Read a boolean option and reject non-boolean values after argparse parsing.

Build the base output name from scene name plus global and scene suffixes.

Deep-merge two dictionaries without mutating either input.

Resolve and cache the final Gaussian count used by GNS pruning. `num` mode uses a fixed count. `rate` mode converts a keep percentag

Save a JSON file with the shared format and create parent folders automatically.

Return a timer value after pending CUDA work has finished. CUDA kernels are asynchronous, so synchronization is needed before timing

Convert a DC spherical-harmonic coefficient back to RGB.

Create the 2D placeholder tensor passed to the rasterizer. The CUDA backward pass writes gradients into this tensor. Channels 0-1

Accumulate normal screen-space gradient magnitudes for visible Gaussians.

Add a repeat index to the output name when the config runs repeats.

Convert normalized quaternions into 3x3 rotation matrices.

Merge train arguments and inject source/model paths for one scene run.

Convert one scene output directory into train/test CSV rows.

Append newly collected rows into the split-indexed row accumulator.

Read a PLY point cloud into the BasicPointCloud container.

Convert field of view in radians to focal length in pixels.

Return an exponential learning-rate schedule function. The returned helper starts near `lr_init`, ends at `lr_final`, and can

Common render entry point used by training and evaluation code. It currently forwards directly to `render_3dgs`, which keeps call si

Render one view in inference mode without keeping training gradients.

Write xyz and RGB arrays as a PLY point cloud with zero normals.

Initialize accumulators and optimizers for the current Gaussian tensors.

Convert RGB values in `[0, 1]` to the DC spherical-harmonic coefficient.

Apply the per-image exposure matrix learned during training. Exposure is stored by image name. The helper multiplies RGB by the

Build rasterizer settings shared by the MiniGS auxiliary and depth paths. The settings mirror the main renderer, but use the MiniGS

Validate and return the configured optimizer type for dense Gaussian tensors.

Rotate vectors by normalized quaternions stored as `[w, x, y, z]`.

Sample alive Gaussian indices by opacity and count how often each one is used.

Build relocated child parameters from selected source Gaussians.

Choose a candidate GPU and create its lock file atomically. The atomic file creation step is what prevents another process from

Accumulate `abs(dx)` and `abs(dy)` written by CUDA backward for ImprovedGS densification scoring. When `sync_default_accumulator=True`, a

Copy terminal log lines into a log file and add a timestamp to each non-empty line.

Keep the top-opacity Gaussians until the exact final budget is reached.

When an output folder with the same name already exists, rename the old folder by its training timestamp to avoid overwriting results.

Create the Beijing-time timestamp used in experiment records.

Build the final Python command list passed to subprocess.

Resolve the input data folder and output folder for one scene run.

Build Camera objects for every CameraInfo entry in a scene split.

Initialize Gaussian tensors from an input point cloud. Positions and colors come from the point cloud, scales are estimated

Clone small high-gradient Gaussians using the original 3DGS rule. Unlike split, cloning keeps the original Gaussian and appe

Split large high-gradient Gaussians using the original 3DGS rule. Selected parents generate `N` children sampled from their

Expand stored SH coefficients when the target degree needs more channels. Returns True only when the tensor was actually exp

Mark GNS pruning as complete and restore the opacity learning rate. The completion message is written both to tqdm and to the experi

Compute scene translation and radius from training camera centers.

Return test cameras for the requested resolution scale.

Build a world-to-view matrix and apply optional scene translation/scale.

Return the learned or loaded exposure matrix for one image name.

Load raw Gaussian tensors from a saved PLY file. When train/test exposure is enabled, exposure matrices are loaded

Normalize a tensor into `[0, 1]` while handling NaN and infinite values.

Increase the active SH degree by one, expanding capacity first if needed.

Provide a lightweight pruning entry point that RAP and GNS can call without running densification.

Compute PSNR for each image in a batch.

Convert a COLMAP quaternion `[w, x, y, z]` into a rotation matrix.

Read Blender/NeRF transform JSON and convert frames into CameraInfo records.

Recreate total CSV files from existing per-scene result summaries.

Rebind all optimizer parameter objects to current model tensors. When indices are provided, only those momentum entries are

Clamp all activated opacities to a maximum value and update optimizer state.

Run one command with an optional CUDA_VISIBLE_DEVICES override.

Set deterministic seeds, select CUDA device 0, and optionally timestamp stdout.

Check whether repeat outputs should be collapsed to the best PSNR run.

Compute structural similarity between two image batches.

Let GNS raise the opacity learning rate during regularized pruning and restore it afterward.

Write rows for one split into the config-level total CSV file.

Resize a PIL image and convert it to a channel-first float tensor.

Shape isotropic noise by each Gaussian's local covariance.

Apply MiniGS's delayed SH-degree schedule. MiniGS keeps low SH capacity early, then restores the dataset target degree and r

Build rasterizer settings for the main 3DGS render call. These settings choose image size, camera transforms, active SH degree,

Build the alpha mask used to ignore invalid image regions. RGBA images provide the base mask. In train/test exposure experiments,

Build the projection matrix expected by the MiniGS reference kernels. MiniGS auxiliary and depth outputs depend on the exact project

Build one optimizer parameter group per Gaussian tensor family. Separate groups keep learning rates independent for xyz, col

Build the fixed white or black CUDA background tensor for training renders.

Collect the statistics needed by the selected densification method. Standard 3DGS uses normal screen-space gradients, ABSGS/Improved

Update MiniGS gradient stats and return the blur mask for split decisions. The normal 3DGS gradient accumulator is updated first. A

Compute the active Gaussian budget for the current densification step. Early iterations use a square-root warmup toward the configur

Compute edge-aware Gaussian importance scores for ImprovedGS. It renders sampled training views with edge maps as pixel weights, the

Combine pixel L1 loss and fused SSIM into the standard 3DGS image loss.

Recreate optimizers and learning-rate schedules from current tensors. This is called both at initial setup and after methods

Enable renderer debug mode one iteration before the requested debug step. The rasterizer uses the flag during the next render call,

Fill `args.model_path` with a unique output folder when it is empty.