TripoSRModel<T>
Models & Types · AiDotNet.Diffusion.ThreeD
TripoSR model for ultra-fast feed-forward single-image 3D reconstruction using LRM transformer.
Inheritance: DiffusionModelBase<T> → LatentDiffusionModelBase<T> → ThreeDDiffusionModelBase<T> → TripoSRModel<T>
For Beginners
TripoSR creates 3D meshes from a single photo in half a second.
How TripoSR works:
- Input image is encoded by DINO-v2 into 768-dim features
- Transformer predicts triplane features (3 orthogonal 2D feature planes)
- Any 3D point is queried by projecting onto each plane and interpolating
- NeRF-like MLP decodes triplane features to density and color
- Marching cubes extracts mesh from the density field
- Texture is extracted from the color predictions
Key characteristics:
- ~0.5 second generation on GPU (fastest image-to-3D)
- Large Reconstruction Model (LRM) architecture
- Triplane representation for efficient 3D encoding
- Feed-forward: no iterative optimization or diffusion sampling
- High-quality textured meshes from single images
- Open-source (StabilityAI + Tripo)
When to use TripoSR:
- Real-time 3D reconstruction from images
- Interactive applications requiring instant 3D
- High-throughput 3D asset pipelines
- When speed is the primary concern
Limitations:
- Quality may be lower than optimization-based methods
- Limited to single-object, object-centric scenes
- Triplane resolution limits geometric detail
- Less accurate for thin structures
How It Works
TripoSR uses a Large Reconstruction Model (LRM) architecture with a transformer backbone that predicts triplane features from a single image in ~0.5 seconds. The triplane representation is decoded into a textured 3D mesh via marching cubes.
Architecture components:
- Transformer backbone (1024 hidden, 16 layers, 16 heads) for triplane prediction
- DINO-v2 image encoder for 768-dim conditioning
- Triplane representation (3 orthogonal feature planes)
- NeRF-like volume decoder from triplane features
- Marching cubes mesh extraction
- Feed-forward: single pass, no diffusion iteration
Technical specifications:
- Architecture: LRM (Large Reconstruction Model) with transformer
- Hidden dimension: 1024
- Transformer layers: 16
- Attention heads: 16
- Image encoder: DINO-v2 (768-dim)
- 3D representation: Triplane features
- Mesh extraction: Marching cubes
- Generation time: ~0.5 seconds
- Feed-forward: Yes (1 inference step)
- Default point count: 8,192
- Open-source: Yes (MIT license)
Reference: Tochilkin et al., “TripoSR: Fast 3D Object Reconstruction from a Single Image”, 2024
Example
var tripoSR = new TripoSRModel<float>();
var mesh = tripoSR.GenerateMesh(
prompt: "A wooden chair",
resolution: 256,
numInferenceSteps: 1,
guidanceScale: 1.0);
Constructors
| Constructor | Summary |
|---|---|
TripoSRModel(NeuralNetworkArchitecture<T> architecture, DiffusionModelOptions<T> options, INoiseScheduler<T> scheduler, DiTNoisePredictor<T> transformer, StandardVAE<T> vae, IConditioningModule<T> conditioner, int defaultPointCount, int? seed) |
Properties
| Property | Summary |
|---|---|
IConditioningModule<T> Conditioner { get; } |
|
INoisePredictor<T> NoisePredictor { get; } |
|
IVAEModel<T> VAE { get; } |
|
bool SupportsMesh { get; } |
|
bool SupportsNovelView { get; } |
|
bool SupportsPointCloud { get; } |
|
bool SupportsScoreDistillation { get; } |
|
bool SupportsTexture { get; } |
|
int LatentChannels { get; } |
Methods
| Method | Summary |
|---|---|
Mesh3D<T> GenerateMesh(string prompt, string negativePrompt, int resolution, int numInferenceSteps, double guidanceScale, int? seed) |
|
ModelMetadata<T> GetModelMetadata() |
|
Tensor<T> GeneratePointCloud(string prompt, string negativePrompt, int? numPoints, int numInferenceSteps, double guidanceScale, int? seed) |