ply_io_benchmark

KO | EN

gitlite — search

#python #hacktoberfest #ai #go #deep-learning #macos #nodejs #java #kubernetes #awesome-list #pytorch #ios #mcp #open-source

ply_io_benchmark

(★ 26)

A simple benchmark comparing various libraries for ply file i/o

ply_io_benchmark Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Ply File I/O Benchmark

This repository contains code for comparison of various libraries for input and output of PLY files. [PLY file format](https://en.wikipedia.org/wiki/PLY_(file_format)) has been developed at Stanford University by [Greg Turk](https://www.cc.gatech.edu/~turk/) as a part of the [real-world object digitization project](http://graphics.stanford.edu/data/3Dscanrep/) undertaken by Stanford University in mid-90s.

## Task
The task is to read and write a basic triangle mesh stored in a PLY. The triangle mesh is represented as a list of vertices and a list of triangles, indicating which triplets of vertices make a triangle.

The data structure we wish to populate is:
~~~~
typedef struct vec3f
{
  float x,y,z;
} Vec3f;

typedef struct tri
{
  int index1, index2, index3;
} Tri;

typedef struct triangle_mesh
{
  int n_verts;
  int n_faces;
  Vec3f* vertices;
  Tri* faces;
} TriMesh;
~~~~

The meshes we are testing were processed to contain only the position attribute and only triangle faces. As such this task aims to measure the speed at which each library is able to exchange simple triangular mesh data. Each of the meshes is tested using both binary and text(ASCII) formats, as supported by PLY file format. For binary we use little-endian.

### Mesh size vs. number of meshes

This benchmark focuses on rather large meshes (15k - 28 million triangles). The use case this benchmark analyzes is to minimize the time taken to load such large meshes. If your task is to read a lot of smaller .ply files, then this benchmark might not be reflective of your situation.

For an alternative task, where a large number of smaller meshes is parsed, and where meshes might have more varied per-vertex attribute list, please see the excellent [ply-parsing-perf](https://github.com/vilya/ply-parsing-perf) benchmark by Vilya Harvey.

### Known list size
Given that in our task we process only triangular meshes, it would be good to let the application know this information. 
Some libraries (see below) allow passing the expected size of list properties, leading to non-negligible speed-up in parsing. As such, where applicable, this feature has been enabled.

### Test Models

The table below lists models used for this benchmark, along with the source.

|     Model Name                | N. Vertices |  N. Tris | Source |
|:-----------------------------:|:-----------:|:--------:|:------:|
| suzanne                       |        7958 |    15744 | Blender
| scannet_scene0402_00          |       93834 |   177518 | [Scannet](http://www.scan-net.org/)
| angel                         |      237018 |   474048 | [Large Geometric Models Archvive](https://www.cc.gatech.edu/projects/large_models/)
| blade                         |      882954 |  1765388 | [Large Geometric Models Archvive](https://www.cc.gatech.edu/projects/large_models/)
| hand                          |      327323 |   654666 | [Large Geometric Models Archvive](https://www.cc.gatech.edu/projects/large_models/)
| horse                         |      48485  |    96966 | [Large Geometric Models Archvive](https://www.cc.gatech.edu/projects/large_models/)
| armadillo                     |      172974 |   345944 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| bunny                         |       35947 |    69451 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| dragon                        |      437645 |   871414 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| happy_buddha                  |      543652 |  1087716 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| lucy                          |    14027872 | 28055742 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| xyzrgb_dragon                 |     3609600 |  7219045 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| xyzrgb_statuette              |     4999996 | 10000000 | [Stanford 3D Scaning Repository](http://graphics.stanford.edu/data/3Dscanrep/)
| bust_of_sappho                |      140864 |   281724 | [Thingiverse](https://www.thingiverse.com/thing:14565)
| statue                        |      999517 |  1999038 | [Sketchfab](https://sketchfab.com/3d-models/william-huskisson-statue-ee9ce7c99f2d4b40aa46aaffb02bf21d)
| speeder_bike                  |     1473341 |  2947046 | [Sketchfab](https://sketchfab.com/3d-models/speeder-bike-from-star-wars-galaxys-edge-dcddea22a0674737b4201a025a27a94d)
| armchair                      |       11558 |    23102 | [Sketchfab](https://sketchfab.com/3d-models/lounger-armchair-e9d9d87c32f144e2873765e66814f727)
| bust_of_angelique_dhannetaire |      250000 |   500000 | [Sketchfab](https://sketchfab.com/3d-models/bust-of-angelique-dhannetaire-26c23265310a4e45aaa296d02db83cb2)

## Libraries

Below is a list of libraries used in this benchmark:

For the usage examples, as well as some additional comments about each of the libraries please check the tests/*_test.c(pp) files.

## Results

Below we present results for parsing PLY files storing data in both ASCII and binary format (little-endian). Times are given in milliseconds. Highlighted numbers indicate the best method in each category.
As noted before, where applicable, a known list size is passed to the library.

The benchmark was compiled using MSVC 19.44.35219 with \O2 optimization flag, using AMD Ryzen 9 9950X3D and Samsung 990 PRO.

To run the test, we run a separate program for each file that attempts to read and write the input file, and reports time taken to do so. Program for each library is run 10 times and the results are averaged. 
The averaged time taken for each model is used to compute the overall average time it took to process all the models.

*Disclaimer*: I am the author of msh_ply library. If you see any deficiencies in the test code for other libraries, don't hesitate to let me know - I hope to make this benchmark as fair as possible.

### Average Read Times

|Method     |  ASCII             |         Binary    |
-----------:|-------------------:|------------------:|
|happly     |    6512.432(47.4x) |    343.835(20.5x) |
|microply   |      503.298(3.7x) |               N/A |
|miniply    |  **137.286(1.0x)** |      20.729(1.2x) |
|mshply     |      942.823(6.9x) |      22.553(1.3x) |
|nanoply    |    2889.588(21.0x) |      57.136(3.4x) |
|plylib     |     1295.420(9.4x) |    236.519(14.1x) |
|PLYwoot    |      430.892(3.1x) |  **16.737(1.0x)** |
|rply       |      666.417(4.9x) |     149.689(8.9x) |
|tinyply21  |    4510.273(32.9x) |    897.768(53.6x) |
|tinyply22  |    2794.483(20.4x) |    177.231(10.6x) |
|tinyply23  |    2795.661(20.4x) |    176.864(10.6x) |
|turkply    |      871.158(6.3x) |    319.420(19.1x) |

### Average Write Times

|Method      |           ASCII    |            Binary  |
|-----------:|-------------------:|-------------------:|
|happly      |    4251.708(14.2x) |     733.696(20.8x) |
|mshply      |    1511.551(5.1x)  |   **35.242(1.0x)** |
|nanoply     |    3227.812(10.8x) |       55.714(1.6x) |
|plylib      |    1231.592(4.1x)  |      198.134(5.6x) |
|PLYwoot     |  **299.168(1.0x)** |       69.097(2.0x) |
|rply        |    1478.005(4.9x)  |      118.080(3.4x) |
|tinyply21   |    3543.509(11.8x) |     547.373(15.5x) |
|tinyply22   |    3575.069(12.0x) |      207.699(5.9x) |
|tinyply23   |    3347.977(11.2x) |      209.590(5.9x) |
|turkply     |    1538.652(5.1x)  |      338.245(9.6x) |

**Notes**:
 - For absolute fastest binary read times, use PLYwoot. Kinda taken aback by the speed. Also incredibly fast ASCII writes!
 - miniply offers great performance for reading both aSCII and binary. Great choice for C++
 - miniply and micro_ply do not support the writing of ply files.
 - micro_ply does not support binary files, only ASCII format.
 - In C, when you need decent read and write performance, msh_ply is a good choice ;). However, it's ASCII mode requires work, so if your models are mostly stored in ASCII, you might want to use other libraries.
 - Some libraries were modified to include getter to establish whether input is binary or ASCII.
 - In ASCII mode, happly is unable to convert between __uint__ and __int__. Since some models (angel, bust_of_sappho, bust_of_angelique_dhannetaire ) contain vertex list specified as __uint__, while others use __int__, happly fails to parse the two aforementioned models and would need to be recompiled to support the specific type. Here, we simply omit these models when benchmarking happly.
 - The assets folder contains older tables run using older machine with AMD Ryzen 3900XT and Samsung 970 EVO PLUS. Old tables below. They do not include PLYwoot
 
<details>
<summary> Average read times</summary>

|Method     | ASCII             |           Binary   |
-----------:|------------------:|-------------------:|
|happly     |  19104.671(75.3x) |     589.435(16.4x) |
|micro_ply  |    1131.752(4.5x) |              N/A   |
|miniply    | **253.671(1.0x)** |   **35.935(1.0x)** |
|msh_ply    |    2009.957(7.9x) |       40.885(1.1x) |
|nanoply    |   8003.712(31.6x) |      106.312(3.0x) |
|plylib     |   3157.350(12.4x) |      338.514(9.4x) |
|rply       |    1731.580(6.8x) |      327.164(9.1x) |
|tinyply21  |  11583.986(45.7x) |    1844.445(51.3x) |
|tinyply22  |   7561.799(29.8x) |      318.069(8.9x) |
|tinyply23  |   7500.844(29.6x) |      294.265(8.2x) |
|turkply    |    2086.552(8.2x) |      549.367(15.3x)|

</details>

<details>
<summary> Average Write Times

|Method      |           ASCII    |            Binary  |
|-----------:|-------------------:|-------------------:|
|happly      |    11534.080(3.8x) |    1454.963(19.8x) |
|msh_ply     |     4178.405(1.4x) |   **73.406(1.0x)** |
|nanoply     |     8772.179(2.9x) |      107.735(1.5x) |
|plylib      | **3045.147(1.0x)** |      315.647(4.3x) |
|rply        |     3966.512(1.3x) |      261.940(3.6x) |
|tinyply21   |     9667.221(3.2x) |    1449.753(19.7x) |
|tinyply22   |     9870.520(3.2x) |      526.407(7.2x) |
|tinyply23   |     9653.622(3.2x) |      560.677(7.6x) |
|turkply     |     4017.640(1.3x) |      624.668(8.5x) |

</details> dw

### Per model I/O times:

**Note** The images show the read time on a log scale, since the performance of different libraries is significantly different.

[Large Geometric Models Archvive]: https://www.cc.gatech.edu/projects/large_models/index.html
[Stanford 3D Scaning Repository]: http://graphics.stanford.edu/data/3Dscanrep/

ply_io_benchmark

ply_io_benchmark Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

ply_io_benchmark

ply_io_benchmark Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README