LATO.2 factorizes mesh generation into a vertex flow (V-Flow) that generates vertex positions under a controllable vertex count, and a topology flow (T-Flow) that predicts connectivity from the realized vertices. This decomposition unlocks:

• High-quality generation (bottom left).
• Part-wise generation (bottom middle).
• Topology-adaptive editing (bottom right).

Installation

1. Clone the repo:

   git clone https://github.com/LoHhhha/LATO.2.git
   cd LATO.2
   

2. Install the dependencies:

   The setup script creates a conda env named lato2 (Python 3.10, PyTorch 2.6.0, CUDA 12.4). A CUDA toolkit (nvcc) is required to build the CUDA extensions.

   . ./setup.sh --all
   

Checkpoints

Download the pretrained weights from the Hugging Face Hub into ckpt/:

python scripts/ckpt_download.py

Inference

All inference scripts take a directory of input meshes (--mesh_dir) and write results to --out_dir. Three bundled examples live in assets/example_mesh/.

Quick start

python scripts/e2e_inference.py \
  --mesh_dir assets/example_mesh \
  --out_dir outputs/e2e_run/example \
  --vert_num 2000

End-to-end (e2e_inference.py)

Full V-Flow → T-Flow pipeline: input mesh → conditioning view → generated vertices → generated topology. Outputs per mesh: <id>_pred.obj (generated mesh), <id>_pred.ply (vertices), the voxel-coordinate variants (*_coords.*, in [0, 1024)), and <id>_render.png (the DINOv2 conditioning view).

python scripts/e2e_inference.py \
  --mesh_dir <dir> \
  --out_dir outputs/e2e_run/<dir> \
  --vert_num <vert_num> \
  [--batch_size 4]

V-Flow (vflow_inference.py)

First stage only — generates vertices from the conditioning view (optionally also reconstructs them via the VAE with --reconstruct). Outputs the generated / GT / reconstructed vertex PLYs plus the render.

python scripts/vflow_inference.py \
  --mesh_dir <dir> \
  --out_dir outputs/vflow_run/<dir> \
  --vert_num <vert_num> \
  [--batch_size 4]

V-VAE (vvae_inference.py)

Vertex-VAE reconstruction only — encodes the input vertices and decodes them back at sub-voxel precision. Outputs the GT and reconstructed vertex PLYs.

python scripts/vvae_inference.py \
  --mesh_dir <dir> \
  --out_dir outputs/vvae_run/<dir> \
  [--batch_size 4]

T-Flow (tflow_inference.py)

Second stage only — generates connectivity for the input vertices, conditioned on the voxel scaffold. Outputs <id>_pred.obj (generated mesh), the known vertices fed to the flow, and the conditioning field.

python scripts/tflow_inference.py \
  --mesh_dir <dir> \
  --out_dir outputs/tflow_run/<dir> \
  [--batch_size 4] \
  [--no-use_cond]

Controlling the vertex count

The V-Flow stage (e2e_inference.py / vflow_inference.py) generates a controllable number of vertices:

• Fixed target (default): --vert_num <N> (default 2000).
• Scaled from the input: --use_gt_vert_count --scaler <s> uses the input mesh's own vertex count multiplied by <s>.

Either way the count is clamped to [--min_verts, --max_verts] (defaults 200–5000).

Notes

• Hardware: runs in ~8 GB VRAM; end-to-end generation takes ~5 s per mesh on a single H800.
• Image-to-structure: to obtain the coarse voxel scaffold from a single image (instead of an existing mesh), you can directly reuse TRELLIS's sparse-structure stage.

Acknowledgements

Our work builds upon these excellent repositories:

• TripoSF
• TRELLIS
• TRELLIS.2
• LATO

Citation

@misc{long2026lato2factorized3dmesh,
      title={LATO.2: Factorized 3D Mesh Generation with Vertex and Topology Flow}, 
      author={Hang Long and Tianhao Zhao and Junkai Lin and Youjia Zhang and Huipeng Guo and Rendong Liang and Jiale Xu and Jozef Hladký and Matthias Nießner and Yuanming Hu and Wei Yang},
      year={2026},
      eprint={2607.10623},
      archivePrefix={arXiv},
      primaryClass={cs.GR},
      url={https://arxiv.org/abs/2607.10623}, 
}