Balancing geometric complexity and visual fidelity is a core technical challenge for mobile 3D development, digital twin, and other scenarios with strict real-time rendering performance requirements.
In this competition, participants are required to compress high-complexity original high-poly meshes with millions of vertices as aggressively as possible — using as few vertices as they can — while keeping the result visually faithful to the original and maintaining complete basic topological structure.
Different from traditional geometry-deviation-oriented algorithms, this competition emphasizes perception-driven optimization. Participants shall adopt perceptual metrics, such as pixel-level rendering consistency and visual saliency features, to ensure that the simplified mesh achieves visually indistinguishable effects from the original high-poly model in light-shadow performance, contour edges, and key details.
To quantitatively measure the visual consistency between the simplified mesh
Centered on the mesh origin, the evaluator places virtual cameras along six positive/negative axial directions in the 3D Cartesian coordinate system to build a multi-view sampling space.
For each view
where
Here:
-
$D$ is the fixed observation distance. -
$D = 2.5$ model units. - Cameras face the mesh origin from the positive/negative directions of the
$x$ ,$y$ , and$z$ axes respectively.
The input mesh is given pre-normalized, as described in the Input section: it is centered at the origin and scaled to lie within the unit sphere,
The evaluator renders these coordinates directly at distance
From each view, the system renders 3D geometric data into two types of feature images for subsequent similarity scoring.
The system generates feature maps from light-shadow and geometric morphology dimensions to calculate SSIM, that is, Structural Similarity Index Measure.
Surface normal determines light reflection effect.
The evaluator uses flat shading: each triangular face has a single unit normal, and every pixel covered by that face is assigned this same face normal. Normals are not interpolated across the face, because the input provides no per-vertex normals.
The normal is mapped to RGB color values:
where:
-
$n(p)$ is the unit normal of the triangular face covering pixel$p$ . -
$n(p)$ is constant across that face. - Each component of
$n(p)$ ranges from$-1$ to$1$ . - Adding
$(1,1,1)$ normalizes the range to$[0,2]$ . - Multiplication by
$127.5$ remaps values to$[0,255]$ to generate standard RGB pixel values.
This map records the depth value
For any pixel
Let the three vertex depths be
Then the reciprocal depth
The purpose of the depth map is to monitor mesh volume shrinkage and contour aliasing, ensuring consistent occlusion relationships and edge silhouettes between the simplified and original meshes.
To generate the above feature maps, the system builds a precise mapping from 3D space to 2D pixel arrays, including two core steps:
- Spatial projection.
- Attribute interpolation.
The camera is placed at the origin facing the negative
For any 3D vertex
of the mesh in camera space, the projected 2D screen pixel coordinate
where:
-
$(X_c,Y_c,Z_c)$ are 3D coordinates in camera space. - The camera is treated as the origin.
- The camera looks along the negative
$z$ -axis. -
$f$ is the virtual camera focal length in pixel units. -
$f = 800.0$ px. -
$(c_x,c_y)$ is the image principal point offset. -
$(c_x,c_y)$ equals half the feature map width and height, so that the projected mesh is centered. -
$(u,v)$ is the floating-point pixel index on the feature map, which is subsequently rasterized to discrete grid pixels.
After confirming which triangle contains pixel
The normal is the covering face’s flat normal, so it needs no interpolation.
The depth is interpolated from the three vertex depths
For pixel
where:
-
$p_1,p_2,p_3$ are the 2D screen coordinates of the three projected triangle vertices. -
$\lambda_i$ represents the contribution of vertex$i$ to pixel$p$ .
Based on these barycentric weights, the per-pixel depth is interpolated perspective-correctly. The quantity linear in screen space is the reciprocal
\lambda_1 \frac{1}{z_1} + \lambda_2 \frac{1}{z_2} + \lambda_3 \frac{1}{z_3}. $$
Therefore,
\frac{1}{ \lambda_1 / z_1 + \lambda_2 / z_2 + \lambda_3 / z_3 }. $$
The face normal is constant over the triangle and is written directly, with no interpolation.
Feature maps are the two types of 3D-rendered 2D images defined above, serving as the direct inputs for SSIM evaluation.
The normal map stores surface normal direction mapped to RGB color, for light-shadow quality evaluation.
The depth map stores linear grayscale depth values, for contour and occlusion evaluation.
Each pixel is sampled once, at its center:
It is covered by the nearest triangle whose projection contains that point and takes that triangle’s flat face normal and its perspective-correct interpolated depth.
Pixels covered by no triangle take the background values described below.
Fixed background values are assigned to pixels with no triangular mesh intersection.
The background normal is
which is mapped to neutral gray:
The background depth is
This corresponds to the far plane depth value.
Participants do not need to use the following camera parameters. However, they are provided to help in designing algorithms.
| Parameter | Symbol | Value | Description |
|---|---|---|---|
| Observation Distance | Distance from camera to mesh origin, in model units | ||
| Focal Length |
|
Controls projection scaling ratio | |
| Background Depth | Far clipping plane depth value | ||
| Background Normal | Background normal vector mapped to neutral gray |
The fixed feature map resolution is
and the principal point is located at the image center:
Submitted simplified meshes must satisfy the following constraints. If they do not, the submission will receive Wrong Answer and the violated constraint will be reported.
The simplified mesh must satisfy the following conditions:
- Vertex count:
A submission with
or
is rejected.
- Manifold mesh: each edge is shared by exactly two triangular faces. The mesh must be a closed, watertight 2-manifold.
- Non-degenerate faces: all triangular faces have positive area.
- Valid indices: all face indices are within the vertex array range.
The symmetric Hausdorff distance between the original mesh
The symmetric Hausdorff distance is defined as:
where
The first direction requires every original vertex to remain covered by the simplification. The second direction forbids simplified vertices from straying away from the original surface.
Let the original vertex bounds be
and
The AABB edge lengths are:
The diagonal length is defined as:
$$ L_{\mathrm{AABB}}=
\sqrt{ (\Delta x)^2 + (\Delta y)^2 + (\Delta z)^2 }. $$
This normalization limits Hausdorff tolerance to 5% of mesh size, independent of original mesh scale.
Subject to the constraints above, participants shall minimize the vertex count of the simplified mesh, equivalently maximizing the compression rate defined in the ranking rules.
A submission is valid only if its multi-view perceptual score stays at or above the threshold
The score is defined as:
$$ \mathrm{Score}(M_o,M_s)=
\frac{1}{6} \sum_{i=1}^{6} \left( w_N \cdot \operatorname{SSIM} \left( N_i^{o}, N_i^{s} \right) + w_D \cdot \operatorname{SSIM} \left( D_i^{o}, D_i^{s} \right) \right). $$
where:
-
$i$ is the view index, with a total of 6 axial views. -
$N_i^{o}$ and$D_i^{o}$ are the normal map and depth map of the original mesh at view$i$ . -
$N_i^{s}$ and$D_i^{s}$ are the normal map and depth map of the simplified mesh at view$i$ . -
$\operatorname{SSIM}$ is the Structural Similarity Index function, with output range$[0,1]$ . - A value of 1 represents full visual consistency.
-
$w_N$ is the weight coefficient of the normal map. -
$w_D$ is the weight coefficient of the depth map. - The final score is the arithmetic mean score of six views.
For two input images
\frac{ (2\mu_X\mu_Y + C_1) (2\sigma_{XY} + C_2) }{ (\mu_X^2 + \mu_Y^2 + C_1) (\sigma_X^2 + \sigma_Y^2 + C_2) }. $$
where:
-
$\mu_X$ and$\mu_Y$ are mean pixel values inside a local sliding window. -
$\sigma_X^2$ and$\sigma_Y^2$ are local pixel variances. -
$\sigma_{XY}$ is local cross-covariance. -
$C_1$ and$C_2$ are stabilization constants.
The constants are:
where:
and the 8-bit pixel dynamic range is
The final image SSIM is the mean of the per-window SSIM values taken over the rendered foreground only.
A window is included when the original and/or simplified rendering is non-background at the window’s center pixel. Windows whose center pixel is the background value in both the original and the simplified rendering are excluded.
The same foreground-only averaging is applied to each channel of the normal map and to the depth map.
For RGB normal maps, SSIM is calculated on the three color channels respectively, then averaged for the final result.
A submission is valid only if its total score satisfies:
Submissions below the threshold get 0 points and are excluded from ranking.
The compression rate is defined as:
1 - \frac{|V_s|}{|V_o|}, $$
where:
-
$|V_s|$ is the vertex count of the simplified mesh. -
$|V_o|$ is the vertex count of the original mesh.
For all valid submissions, ranking priority is determined by simplified vertex count.
Filter valid meshes with:
If
then the score of this test case is 0.
For each test case, the score is the compression rate.
For all test cases, the final score is the average of the test-case scores.
Across all test cases, the vertex count is at most TODO, and the face count is at most TODO.
Per-test-case size bounds are listed in the table below.
| Test Case | Vertex Count Bound | Face Count Bound |
|---|---|---|
| 1, sample | 10 | 15 |
| 2 | 5000 | 10000 |
| 3 | 25000 | 50000 |
| 4 | 40000 | 80000 |
| 5 | 50000 | 100000 |
| 6 | 400000 | 800000 |
| 7 | 1100000 | 2100000 |
Input is read using standard input, stdin.
The input is a slightly modified version of the OBJ file format.
The first line of input contains the integers
where:
-
$n$ is the number of vertices. -
$m$ is the number of faces.
The following v, followed by the real numbers
v x y z
Each coordinate satisfies:
and is given with at most TODO digits after the decimal point.
The mesh is pre-normalized:
- Its axis-aligned bounding box is centered at the origin.
- Therefore,
and likewise for
- Every vertex lies within the unit sphere:
The final f, followed by the integers
f a b c
where:
This means that there is a triangular face connecting the vertices numbered
The input mesh is guaranteed to be a closed, watertight 2-manifold:
- Every edge is shared by exactly two faces.
- The surface is connected.
- Every face is non-degenerate.
- The three vertices of every face are distinct and span a positive area.
- There are no duplicate vertices or duplicate faces.
Check the sample input file below for a precise example of the format.
Write your simplified polygon to standard output, stdout, in the same format as the input.
The output mesh must be manifold. Additionally, it may not have any zero-area degenerate triangular faces.
The output may be at most TODO MiB in total. Thus, you should take care not to print an excessive amount of decimals if your mesh is large.
The baseline solutions described below respect this bound.
Because this problem has a large amount of input, C++ and Python code for quickly reading and writing input/output are provided in the attachments section at the bottom of the page.
These files are provided as-is. You may modify them in any way you see fit, and you may of course choose not to use them.
Additionally, for C++, the library Eigen is available.
The Eigen files will be placed in the same directory as your solution when compiled, and can be included using, for example:
#include "Eigen/Dense"The version provided is Eigen 5.0.0.
You do not need to submit any Eigen files. It may be beneficial to download Eigen for local debugging and development if you choose to use it.
In the sample shown below, the simplified mesh removes a redundant vertex from the right face of the original mesh without changing the face normal and depth.
Therefore,
and the compression rate is:
You are not awarded any points for solving the sample case, but you can use it to debug your solution.
9 14
v 0.5 0.5 0.5
v 0.5 0.5 -0.5
v 0.5 -0.5 0.5
v 0.5 -0.5 -0.5
v -0.5 0.5 0.5
v -0.5 0.5 -0.5
v -0.5 -0.5 0.5
v -0.5 -0.5 -0.5
v 0.5 0.49 0.49
f 1 3 9
f 1 9 2
f 9 3 4
f 9 4 2
f 5 6 8
f 5 8 7
f 1 2 6
f 1 6 5
f 3 7 8
f 3 8 4
f 1 5 7
f 1 7 3
f 2 4 8
f 2 8 6
8 12
v 0.5 0.5 0.5
v 0.5 0.5 -0.5
v 0.5 -0.5 0.5
v 0.5 -0.5 -0.5
v -0.5 0.5 0.5
v -0.5 0.5 -0.5
v -0.5 -0.5 0.5
v -0.5 -0.5 -0.5
f 1 3 4
f 1 4 2
f 5 6 8
f 5 8 7
f 1 2 6
f 1 6 5
f 3 7 8
f 3 8 4
f 1 5 7
f 1 7 3
f 2 4 8
f 2 8 6