### Setup Python Environment with Conda and Pip

Source: https://github.com/wang-zidu/3ddfa-v3/blob/main/README.md

This snippet outlines the steps to set up a Python 3.8 environment using Conda, activate it, and install project dependencies including PyTorch with CUDA support, followed by other requirements from a file. It also covers cloning external libraries like nvdiffrast and building a custom Cython renderer.

```bash
git clone https://github.com/wang-zidu/3DDFA-V3
cd 3DDFA-V3

conda create -n TDDFAV3 python=3.8
conda activate TDDFAV3

# The pytorch version is not strictly required. (Example for CUDA 10.2)
pip install torch==1.12.1+cu102 torchvision==0.13.1+cu102 torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cu102
# or: conda install pytorch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1 cudatoolkit=10.2 -c pytorch
# On Windows 10, version 1.10 has been verified.
# pip install torch==1.10.0+cu102 torchvision==0.11.0+cu102 torchaudio==0.10.0 -f https://download.pytorch.org/whl/torch_stable.html

pip install -r requirements.txt

# Clone and install nvdiffrast
git clone https://github.com/NVlabs/nvdiffrast.git
cd nvdiffrast
pip install .
cd ..

# Build Cython renderer
cd util/cython_renderer/
python setup.py build_ext -i
cd ..
cd ..
```

--------------------------------

### Run Fast 3D Face Reconstruction with MobileNet-V3 (Bash)

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Performs a faster 3D face reconstruction using the MobileNet-V3 backbone. This command-line example specifies input and output paths, device, face detector, and enables landmark detection and texture usage for efficient processing.

```bash
python demo.py \
    --inputpath my_images/ \
    --savepath output/ \
    --device cuda \
    --detector retinaface \
    --backbone mbnetv3 \
    --ldm68 1 \
    --useTex 1
```

--------------------------------

### Facial Segmentation Extraction with 3ddfa-v3

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This Python snippet demonstrates how to extract semantic segmentation masks for 8 facial parts using the 3ddfa-v3 model. It initializes the model with segmentation enabled, performs reconstruction, and then accesses both the raw and visibility-aware segmentation results. It also includes an example of visualizing a specific part and creating a colored overlay of the combined segmentation.

```python
import numpy as np
import cv2
from model.recon import face_model
import argparse

# Initialize with segmentation enabled
args = argparse.Namespace(
    device='cuda', backbone='resnet50',
    ldm68=False, ldm106=False, ldm106_2d=False, ldm134=False,
    seg=True, seg_visible=True,
    useTex=False, extractTex=False
)
recon_model = face_model(args)

# Reconstruct face
# Assuming im_tensor is already defined and on cuda
# im_tensor = torch.randn(1, 3, 224, 224).cuda() 
recon_model.input_img = im_tensor.cuda()
results = recon_model.forward()

# 8-part segmentation without visibility mask
seg = results['seg']  # (224, 224, 8)
# Parts: [right_eye, left_eye, right_eyebrow, left_eyebrow,
#         nose, upper_lip, lower_lip, skin]

# 8-part segmentation with visibility (occlusion-aware)
seg_visible = results['seg_visible']  # (224, 224, 8)

# Visualize specific part
right_eye_mask = seg_visible[:, :, 0]
left_eye_mask = seg_visible[:, :, 1]
nose_mask = seg_visible[:, :, 4]

# Create colored segmentation overlay
colormap = np.array([
    [0, 0, 0],        # background
    [0, 205, 0],      # right eye (green)
    [0, 138, 0],      # left eye (dark green)
    [139, 76, 57],    # right eyebrow (brown)
    [139, 54, 38],    # left eyebrow (dark brown)
    [154, 50, 205],   # nose (purple)
    [72, 118, 255],   # upper lip (orange)
    [22, 22, 139],    # lower lip (dark blue)
    [255, 255, 0],    # skin (yellow)
], dtype=np.uint8)

# Combine all parts
seg_combined = np.zeros((224, 224), dtype=np.uint8)
for i in range(8):
    seg_combined[seg_visible[:, :, i] > 0.5] = i + 1

seg_colored = colormap[seg_combined]
cv2.imwrite('segmentation.png', seg_colored)
```

--------------------------------

### Run 3DDFA-V3 Demo

Source: https://github.com/wang-zidu/3ddfa-v3/blob/main/README.md

Execute the demo script for 3DDFA-V3. This command allows for customization of input/output paths, cropping, face detection methods, landmark saving, segmentation visibility, texture extraction, and the choice of network backbone. Ensure all required assets and pretrained models are prepared beforehand.

```python
python demo.py --inputpath examples/ --savepath examples/results --device cuda --iscrop 1 --detector retinaface --ldm68 1 --ldm106 1 --ldm106_2d 1 --ldm134 1 --seg_visible 1 --seg 1 --useTex 1 --extractTex 1 --backbone resnet50
```

--------------------------------

### Comprehensive Visualization Pipeline - Python

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This snippet outlines the process for generating comprehensive visualization images and data from a reconstructed face. It involves setting up the face model and detector, processing an input image, running the reconstruction, and then using a `visualize` utility to output various visual representations and a .npy file containing landmark and segmentation data. The output includes rendered images and structured data.

```Python
import cv2
import numpy as np
import argparse
from PIL import Image
from util.io import visualize
# Assuming face_model and face_box are imported and initialized

# Complete visualization pipeline
# args = argparse.Namespace(
#     device='cuda', backbone='resnet50',
#     ldm68=True, ldm106=True, ldm106_2d=True, ldm134=True,
#     seg=True, seg_visible=True, useTex=True, extractTex=True
# )

# recon_model = face_model(args)
# detector = face_box(args).detector

# Process image
# im = Image.open('examples/face.jpg').convert('RGB')
# trans_params, im_tensor = detector(im)
# recon_model.input_img = im_tensor.to(args.device)
# results = recon_model.forward()

# Create visualization
# my_visualize = visualize(results, args)
# my_visualize.visualize_and_output(
#     trans_params=trans_params,
#     img=cv2.cvtColor(np.asarray(im), cv2.COLOR_RGB2BGR),
#     save_path='output/',
#     img_name='face'
# )

# Outputs generated:
# - face.png: grid visualization with all results
# - face.npy: dictionary with landmark arrays and segmentations
# - face_pcaTex.obj: 3D mesh with BFM texture
# - face_extractTex.obj: 3D mesh with image-extracted texture

# Load saved results
# saved_data = np.load('output/face.npy', allow_pickle=True).item()
# print(f"Keys: {saved_data.keys()}")
```

--------------------------------

### Run Full 3D Face Reconstruction (Bash)

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Executes the 3DDFA-V3 pipeline for full 3D face reconstruction using specified parameters. It takes an input directory, saves results to an output directory, and can utilize CUDA for acceleration. This command enables various features like different landmark sets, segmentation, texture extraction, and specifies the backbone and face detector.

```bash
python demo.py \
    --inputpath examples/ \
    --savepath examples/results \
    --device cuda \
    --iscrop 1 \
    --detector retinaface \
    --ldm68 1 \
    --ldm106 1 \
    --ldm106_2d 1 \
    --ldm134 1 \
    --seg_visible 1 \
    --seg 1 \
    --useTex 1 \
    --extractTex 1 \
    --backbone resnet50
```

--------------------------------

### Compute 3D Face Shape and Texture

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This Python snippet demonstrates how to initialize the 3ddfa-v3 face model and use it to compute 3D face shape and texture from input image parameters. It covers parameter splitting, shape computation using identity and expression coefficients, albedo calculation, and applying transformations with lighting. Dependencies include PyTorch and NumPy.

```python
import torch
import numpy as np
from model.recon import face_model
import argparse

# Initialize model
recon_model = face_model(argparse.Namespace(
    device='cuda', backbone='resnet50',
    ldm68=False, ldm106=False, ldm106_2d=False, ldm134=False,
    seg=False, seg_visible=False, useTex=False, extractTex=False
))

# Extract parameters from image
im_tensor = torch.randn(1, 3, 224, 224).cuda()
recon_model.input_img = im_tensor
alpha = recon_model.net_recon(im_tensor)

# Split into components (256 total parameters)
alpha_dict = recon_model.split_alpha(alpha)
# alpha_dict keys: 'id' (80), 'exp' (64), 'alb' (80),
#                  'angle' (3), 'sh' (27), 'trans' (2)

# Compute 3D shape (identity + expression)
face_shape = recon_model.compute_shape(
    alpha_dict['id'],   # (1, 80) identity coefficients
    alpha_dict['exp']   # (1, 64) expression coefficients
)
# Returns: (1, 35709, 3) face vertices without pose

# Compute albedo (skin color without lighting)
face_albedo = recon_model.compute_albedo(
    alpha_dict['alb'],  # (1, 80) albedo coefficients
    normalize=True
)
# Returns: (1, 35709, 3) RGB colors in [0, 1]

# Apply rotation
rotation = recon_model.compute_rotation(alpha_dict['angle'])
face_shape_transformed = recon_model.transform(
    face_shape, rotation, alpha_dict['trans']
)

# Compute vertex normals
face_norm = recon_model.compute_norm(face_shape)
face_norm_roted = face_norm @ rotation

# Apply lighting (Spherical Harmonics)
face_texture = recon_model.compute_texture(
    face_albedo,
    face_norm_roted,
    alpha_dict['sh']  # (1, 27) lighting coefficients
)

print(f"Shape: {face_shape.shape}, Texture: {face_texture.shape}")
```

--------------------------------

### Batch Processing Face Images with 3DDFA-V3

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Illustrates efficient batch processing of multiple face images using the 3DDFA-V3 model. It covers loading images, initializing the reconstruction model and face detector once, iterating through images, performing reconstruction, and saving the visualization outputs to a specified directory. Dependencies include os, glob, PIL, and custom util modules.

```python
import os
import glob
from PIL import Image
from util.preprocess import get_data_path
import argparse # Added for argparse.Namespace
from models.facemodel import face_model # Assuming face_model is here
from models.facemodel import face_box # Assuming face_box is here
from util.util import visualize # Assuming visualize is here
import cv2 # Assuming cv2 is used for color conversion

# Get all images in directory
input_path = 'examples/'
im_path = get_data_path(input_path)
print(f"Found {len(im_path)} images")

# Initialize models once
args = argparse.Namespace(
    device='cuda', backbone='resnet50', iscrop=True,
    detector='retinaface', ldm68=True, ldm106=True,
    ldm106_2d=True, ldm134=True, seg_visible=True,
    seg=False, useTex=True, extractTex=True
)
recon_model = face_model(args)
facebox_detector = face_box(args).detector

# Process batch
for i, img_path in enumerate(im_path):
    print(f"Processing {i+1}/{len(im_path)}: {img_path}")

    # Load image
    im = Image.open(img_path).convert('RGB')
    trans_params, im_tensor = facebox_detector(im)

    # Reconstruct
    recon_model.input_img = im_tensor.to(args.device)
    results = recon_model.forward()

    # Save outputs
    img_name = os.path.basename(img_path).replace('.jpg', '').replace('.png', '')
    save_dir = os.path.join('batch_output', img_name)
    os.makedirs(save_dir, exist_ok=True)

    # Visualize and save
    my_visualize = visualize(results, args)
    my_visualize.visualize_and_output(
        trans_params,
        cv2.cvtColor(np.asarray(im), cv2.COLOR_RGB2BGR),
        save_dir,
        img_name
    )

print("Batch processing complete")
```

--------------------------------

### Run CPU-Only 3D Face Reconstruction (Bash)

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Executes the 3D face reconstruction pipeline entirely on the CPU, suitable for environments without GPU support. This command specifies input/output paths, cropping, face detector, landmark detection, and texture usage.

```bash
python demo.py \
    --inputpath examples/ \
    --savepath results/ \
    --device cpu \
    --iscrop 1 \
    --detector mtcnn \
    --ldm68 1 \
    --useTex 1
```

--------------------------------

### Initialize 3D Face Reconstruction Model (Python)

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Initializes the 3D face reconstruction model in Python. It configures reconstruction parameters such as device, backbone, and desired output features like landmarks and segmentation. The model is built using the Basel Face Model (BFM) and a specified neural network backbone.

```python
import argparse
import torch
from model.recon import face_model
from PIL import Image

# Configure reconstruction parameters
args = argparse.Namespace(
    device='cuda',
    backbone='resnet50',  # or 'mbnetv3'
    ldm68=True,
    ldm106=True,
    ldm106_2d=True,
    ldm134=True,
    seg=True,
    seg_visible=True,
    useTex=True,
    extractTex=True
)

# Initialize face model (loads BFM parameters and neural network)
recon_model = face_model(args)

# Model contains:
# - 3D morphable model (identity, expression, albedo bases)
# - Pre-trained ResNet-50 or MobileNet-V3 backbone
# - Renderer for mesh visualization
# - Landmark and segmentation annotations
print(f"Face model initialized on {args.device}")
print(f"Vertex count: 35709, Triangle count: 70789")
```

--------------------------------

### Landmark Detection with 3ddfa-v3

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This Python snippet shows how to use the 3ddfa-v3 model to detect various sets of facial landmarks, including 68, 106 (both 2D and 3D versions), and 134 points. It initializes the model with the desired landmark detection options enabled, performs reconstruction, and then accesses the landmark results from the output dictionary.

```python
import numpy as np
from model.recon import face_model
import argparse

# Initialize with all landmark types
args = argparse.Namespace(
    device='cuda', backbone='resnet50',
    ldm68=True, ldm106=True, ldm106_2d=True, ldm134=True,
    seg=False, seg_visible=False, useTex=False, extractTex=False
)
recon_model = face_model(args)

# Reconstruct and get landmarks
# Assuming im_tensor is already defined and on cuda
# im_tensor = torch.randn(1, 3, 224, 224).cuda()
recon_model.input_img = im_tensor.cuda()
results = recon_model.forward()

# 68 landmarks (standard IBUG annotation)
ldm68 = results['ldm68']  # (1, 68, 2)
# Points: face contour (0-16), eyebrows (17-26), nose (27-35),
#         eyes (36-47), mouth (48-67)

# 106 landmarks (3D)
ldm106 = results['ldm106'] # (1, 106, 2)

# 134 landmarks (3D)
ldm134 = results['ldm134'] # (1, 134, 2)
```

--------------------------------

### Load Face Model Assets - Python

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This code snippet shows how to load and access various components of the face model, including BFM parameters (mean shape, identity/expression bases, mean albedo, albedo basis), topology information (triangles, point buffer, UV coordinates), landmark indices for different landmark sets (68, 106, 134), and segmentation annotations. It also demonstrates generating a custom face shape using PyTorch by combining identity and expression bases.

```Python
import numpy as np
import torch

# Load face model dictionary
# model = np.load("./assets/face_model.npy", allow_pickle=True).item()

# Morphable model components
# u = model['u']           # (107127, 1) mean shape
# id_basis = model['id']   # (107127, 80) identity basis
# exp_basis = model['exp'] # (107127, 64) expression basis
# u_alb = model['u_alb']   # (107127, 1) mean albedo
# alb_basis = model['alb'] # (107127, 80) albedo basis

# Topology
# tri = model['tri']       # (70789, 3) triangle faces
# point_buf = model['point_buf']  # (35709, 8) for normal computation
# uv_coords = model['uv_coords']  # (35709, 3) UV coordinates

# Landmark indices
# ldm68_idx = model['ldm68']    # (68,) vertex indices
# ldm106_idx = model['ldm106']  # (106,) vertex indices
# ldm134_idx = model['ldm134']  # (134,) vertex indices

# Segmentation annotations (8 parts)
# annotation = model['annotation']      # List of vertex indices per part
# annotation_tri = model['annotation_tri']  # List of triangle indices per part

# Profile parallel for 2D landmark matching
# parallel = model['parallel']  # Face profile correspondences

# Generate custom shape
# alpha_id = torch.randn(1, 80)
# alpha_exp = torch.randn(1, 64)
# shape = (torch.tensor(id_basis) @ alpha_id.T +
#          torch.tensor(exp_basis) @ alpha_exp.T +
#          torch.tensor(u)).reshape(-1, 3)
# print(f"Generated shape: {shape.shape}")
```

--------------------------------

### Custom Mesh Rendering with GPU and CPU

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Demonstrates how to initialize and use both GPU (MeshRenderer) and CPU (MeshRenderer_cpu) renderers for visualizing 3D face meshes. It covers the inputs required for rendering (vertices, triangles, colors) and the outputs generated (mask, depth, rendered image, visible vertex indices).

```python
import torch
import numpy as np
from util.nv_diffrast import MeshRenderer  # GPU renderer
from util.cpu_renderer import MeshRenderer_cpu  # CPU renderer

# Initialize renderer (GPU)
renderer = MeshRenderer(
    rasterize_fov=2 * np.arctan(112. / 1015) * 180 / np.pi,
    znear=5.0,
    zfar=15.0,
    rasterize_size=224
)

# Or CPU renderer
renderer_cpu = MeshRenderer_cpu(
    rasterize_fov=2 * np.arctan(112. / 1015) * 180 / np.pi,
    znear=5.0,
    zfar=15.0,
    rasterize_size=224
)

# Render mesh
v3d = torch.randn(1, 35709, 3).cuda()  # 3D vertices in camera space
tri = torch.randint(0, 35709, (70789, 3)).cuda()  # Triangle indices
colors = torch.rand(1, 35709, 3).cuda()  # Vertex colors

mask, depth, rendered_img, visible_idx = renderer(
    v3d.clone(),
    tri,
    colors.clone(),
    visible_vertice=True
)

# mask: (1, 224, 224, 1) binary face mask
# depth: (1, 224, 224, 1) depth map
# rendered_img: (1, 3, 224, 224) rendered image
# visible_idx: vertex indices that are visible

print(f"Rendered image: {rendered_img.shape}")
print(f"Visible vertices: {len(visible_idx)}")
```

--------------------------------

### Transform and Visualize Landmarks - Python

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This snippet demonstrates how to transform extracted landmarks back to the original image space using `back_resize_ldms` and then visualize them on an image using OpenCV. It takes landmark data and transformation parameters as input and outputs an image with drawn landmarks.

```Python
from util.io import back_resize_ldms
import cv2

# Assuming ldm68, ldm106, and trans_params are available from previous steps
# ldm68_original = back_resize_ldms(ldm68[0].copy(), trans_params)
# ldm106_original = back_resize_ldms(ldm106[0].copy(), trans_params)

# Visualize landmarks
img_with_ldm = cv2.imread('examples/portrait.jpg')
# for pt in ldm68_original:
#     cv2.circle(img_with_ldm, (int(pt[0]), int(pt[1])), 2, (0, 255, 0), -1)
cv2.imwrite('landmarks.jpg', img_with_ldm)
```

--------------------------------

### Perform 3D Face Reconstruction Forward Pass (Python)

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Performs the core 3D face reconstruction by running a forward pass on a processed image tensor. This Python code snippet initializes the reconstruction model and face detector, loads an image, preprocesses it, and then feeds it into the model to obtain reconstruction results, including 3D mesh, landmarks, and segmentation.

```python
import torch
from model.recon import face_model
from face_box import face_box

# Setup
args = argparse.Namespace(
    device='cuda', backbone='resnet50',
    ldm68=True, ldm106=True, ldm106_2d=True, ldm134=True,
    seg=True, seg_visible=True, useTex=True, extractTex=True
)
recon_model = face_model(args)
detector = face_box(args).detector

# Load and process image
im = Image.open('examples/portrait.jpg').convert('RGB')
trans_params, im_tensor = detector(im)

# Run reconstruction
recon_model.input_img = im_tensor.to(args.device)
results = recon_model.forward()

```

--------------------------------

### Load Face Model with NumPy (Python)

Source: https://github.com/wang-zidu/3ddfa-v3/blob/main/assets/README.md

Loads the face model and its associated attributes from a .npy file using NumPy. This model contains data like segmentation annotations, triangle faces, and landmark vertex indices. The 'allow_pickle=True' option is necessary for loading .npy files containing arbitrary Python objects.

```python
import numpy as np
model = np.load("./assets/face_model.npy",allow_pickle=True).item()
# Access attributes like:
# model['annotation']
# model['annotation_tri']
# model['ldm106']
# model['parallel']
# model['ldm134']
# model['ldm68']
```

--------------------------------

### Access 3D Face Model Results

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This snippet shows how to access various components of the 3ddfa-v3 model results, such as 3D vertices, 2D projections, texture information, triangle faces, and different sets of facial landmarks. It also demonstrates printing the shapes of these results for verification.

```python
v3d = results['v3d']              # (1, 35709, 3) 3D vertices in camera space
v2d = results['v2d']              # (1, 35709, 2) 2D projections
face_texture = results['face_texture']  # (1, 35709, 3) RGB vertex colors
tri = results['tri']               # (70789, 3) triangle faces
ldm68 = results['ldm68']           # (1, 68, 2) 68 facial landmarks
ldm106 = results['ldm106']         # (1, 106, 2) 106 facial landmarks
ldm134 = results['ldm134']         # (1, 134, 2) 134 facial landmarks
seg_visible = results['seg_visible']  # (224, 224, 8) segmentation masks
render_face = results['render_face']  # (1, 224, 224, 3) rendered image

print(f"Reconstructed {v3d.shape[1]} vertices")
print(f"Landmarks: 68={ldm68.shape}, 106={ldm106.shape}, 134={ldm134.shape}")
print(f"Segmentation parts: {seg_visible.shape[2]}")
```

--------------------------------

### Detect Faces and Preprocess Images (Python)

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

Detects faces in an image and preprocesses them for 3D reconstruction using a specified face detector (RetinaFace or MTCNN). It returns transformation parameters and a normalized image tensor ready for the reconstruction model. This includes handling both cropped and non-cropped image inputs.

```python
import numpy as np
from PIL import Image
from face_box import face_box

# Initialize face detector
detector_args = argparse.Namespace(
    iscrop=True,
    detector='retinaface',  # or 'mtcnn'
    device='cuda'
)
facebox_detector = face_box(detector_args).detector

# Process image
im = Image.open('examples/test_image.jpg').convert('RGB')
trans_params, im_tensor = facebox_detector(im)

# trans_params: [width, height, scale, tx, ty] for reverse transformation
# im_tensor: normalized (1, 3, 224, 224) tensor ready for reconstruction
print(f"Detected face, cropped to {im_tensor.shape}")
print(f"Transform params: {trans_params}")

# For pre-cropped 224x224 images
no_crop_args = argparse.Namespace(iscrop=False)
no_crop_detector = face_box(no_crop_args).detector
_, im_tensor = no_crop_detector(Image.open('cropped_face.jpg'))
```

--------------------------------

### Export 3D Mesh with Textures - Python

Source: https://context7.com/wang-zidu/3ddfa-v3/llms.txt

This code snippet shows how to export reconstructed 3D face meshes in OBJ format with vertex colors. It supports both PCA-based texture from the BFM model and textures extracted directly from the input image. The output OBJ files are compatible with standard 3D software and contain vertex data along with color information.

```Python
import numpy as np
from util.io import write_obj_with_colors

# Assuming results from recon_model.forward() are available
# results = recon_model.forward()

# Prepare vertex coordinates (convert from camera to mesh space)
# v3d_mesh = results['v3d'][0].copy()
# v3d_mesh[..., -1] = 10 - v3d_mesh[..., -1]  # Flip Z coordinate

# Export with PCA-based texture (BFM model colors)
# write_obj_with_colors(
#     obj_name='output_pca_texture.obj',
#     vertices=v3d_mesh,
#     triangles=results['tri'],
#     colors=results['face_texture'][0]
# )

# Export with image-extracted texture
# if 'extractTex' in results:
#     write_obj_with_colors(
#         obj_name='output_extracted_texture.obj',
#         vertices=v3d_mesh,
#         triangles=results['tri'],
#         colors=results['extractTex']
#     )

# OBJ format: v x y z r g b (RGB in [0,1])
print("Exported 3D mesh with 35709 vertices and 70789 faces")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.