[Open3DGC] Examples of encoded streams

Encoded Models

• Bunny
• Buddha
• Ben
• Dragon

Original, encoded and decoded streams are available here 

Compression Results

• 14 bits quantization for positions
• 10 bits quantization for normals and texture coordinates

Open3DGC (more results!)

Encoders

• Open3DGC-Bin: binary version of Open3DGC (14 bits quantization)
• Open3DGC-ASCII: ascii version of Open3DGC (14 bits quantization)
• webgl-loader: the optimized version obj2utf8x (14 bits quantization)
• GZip (default): level=6
• GZip (best): level=9
• 7zip (best): level=9

Test dataset

Results

Open3DGC (updated results)

In a previous post, I reported experimental results comparing the compression efficiency of Open3DGC to webgl-loader and OpenCTM. In this post, I am providing an updated version, which takes into account:

• The "evaluation version" obj2utf8x of webgl-loader, which provides better compression performances than the obj2utf8 encoder, and
• The latest Open3DGC version (slightly better compression).

  

Open3DGC at "COLLADA/glTF" BoF (Siggraph 2013)

Open3DGC was demoed at "COLLADA/glTF" BoF (Siggraph 2013). Check out these two presentations:

• Graphics Library Transmission Format (Fabrice Robinet)
• Rest3D (Remi Arnaud)

Open3DGC (Open 3D Graphics Compression)

I am glad to introduce the Open3DGC (Open 3D Graphics Compression) library!

Open3DGC aims at providing a cross platform C++ implementation (under MIT License) of patent free MPEG tools for 3D graphics compression.

The current Open3DGC version provides an implementation of the MPEG-SC3DMC codec  (Scalable Complexity 3D Mesh Compression). SC3DMC  offers an efficient low complexity solution to compress arbitrary triangular 3D meshes with attributes (e.g., normals, texture coordinate, skinning animation weights, bone IDs..).

A detailed description of the compression algorithm is available here

Open3DGC supports two output stream types:

• Binary streams: compressed using arithmetic encoding
• ASCII (7-bits) streams: adapted for server-side gzip compression and java-script client side decoding

Compression Efficiency

Open3DGC is 7.8 times more efficient than Gzip and 

1.7-2.0 times more efficient than Webgl-loader and OpenCTM

• Test dataset: 160 models with various shapes and topologies (i.e., open/closed, manifold/non-manifold, arbitrary genus)
• Codecs: 
• WebGL-Loader  and Open3DGC with 14 bits quantization for positions and 10 bits quantization for normals/texture coord
• OpenCTM: default parameters  (not fair)

Using the Open3DGC Compression Tool

• The "test_o3dgc" tool supports only OBJ files with a single triangular model
• Pre-built binaries for Win32, Win64 and ubuntu are available here
• Example of test models are located here
• To compress the "bunny" model file use the following command line:

• Binary stream

test_o3dgc.exe -c -st binary -i bunny.obj

• ASCII stream

test_o3dgc.exe -c -st ascii -i bunny.obj

• ASCII streams should be further compressed by using GZip

• To decompress the stream:

test_o3dgc.exe -d -i bunny.s3d

• 
  

V-HACD: Replacing Triangle's Constrained Delaunay Triangulation

As mentioned in my previous post, the first version of V-HACD relies on the library Triangle to compute 2D constrained Delaunay triangulations. In fact, the V-HACD algorithm involves clipping the mesh against a plane and filling the produced holes (cf. Figure 1).

The Triangle library produces excellent results and is very stable. However, as pointed out by Erwin Coumans it has a non permissive license. Another alternative to Triangle is the poly2tri, which is released under a New BSD License. Poly2tri turned out to be non-usable in my case because it supports only simple polygons as constraints. After searching the internet for a "good" and stable implementation with a permissive license, I ended up developing a simple triangulation algorithm (it is not a Constrained Delaunay Triangulation), which is enough for V-HACD needs. My implementation is a very simplified version of the Incremental Delaunay algorithm 

The new triangulation algorithm was uploaded to the git repository and could be compared to the Triangle library by adding #define USE_TRIANGLE to vhacdMesh.cpp

The code is still ugly and not optimized at all. For now, I am trying to have some first results and understand better the algorithm limitations. Hopefully, I'll have soon the time to clean up the code.

This post is out-of-date. Check out V-HACD 2.0!

V-HACD: Hierarchical Approximate Convex Decomposition Revisited

Lately, I have found time to work on improving the HACD algorithm. The new V-HACD library tries to tackle the problem of convex-hulls inter-penetration usually encountered when using HACD. Figure 1 illustrates this limitation by comparing V-HACD results to those generated by using HACD.

Figure 1. V-HACD vs. HACD: V-HACD generates non-overlapping convex-hulls.

V-HACD works only with manifold closed meshes of arbitrary genus, which makes it less general than HACD algorithm (which handles open and non-manifold meshes). The V-HACD code  is available under New BSD License. However, the current version relies on the following other libraries:

• Triangle to compute constrained delaunay triangulation which has a non permissive license, which should be replaced [Thanks to Erwin Coumans for noticing that]
• Ole Kniemeyer's implementation of the convex-hull algorithm provided with bullet
• John Tsiombikas's kd-tree algorithm

The first results are encouraging. However, the code is still buggy and not optimized. I hope that people would be interested in helping me improve this first version.

To play with the algorithm, a pre-compiled win32 executable is available here
Pre-computed decomposition results are available here

V-HACD parameters are the following:

testVHACD fileName.off depth maxConcavity invertInputFaces posSampling angleSampling posRefine angleRefine alpha targetNTrianglesDecimatedMesh

• fileName.off: 3D mesh in off format (type: string, example: block.off )
• depth: maximum number of decomposition stages (type: integer, default: 10)
• maxConcavity: maximum allowed concavity (type: float, default 0.01)
• invertInputFaces: indicates whether mesh normals should be inverted or not (type: boolean, default 0)
• posSampling: clipping plane position sampling resolution for coarse search (type: int, default 10)
• angleSampling: clipping plane orientation sampling resolution for coarse search (type: int, default 10) 
• posRefine: clipping plane position sampling resolution for refined search (type: int, default 5) 
• angleRefine: clipping plane orientation sampling resolution for refined search (type: int, default 5)
• alpha: parameter controlling the compromise between concavity and balance between convex-hulls. (type: float, default: 0.01)
• targetNTrianglesDecimatedMesh: number of triangles in the decimated mesh. V-HACD decimates the input mesh to reduce computation times. (type: integer, default: 1000)

To apply V-HACD to the input mesh "input.off" use the following command line:

testVHACD.exe input.off 30 0.01 0 64 32 8 64 0.001 2000

Below, some screen-shots of the obtained results.

The current version of V-HACD provides poor results or errors for the following three meshes. As soon as I get some free time I'll try to fix these bugs.

• dancer2
• elk
• hand1
• hand2
• hero
• octopus
• polygirl
• shark_b
• Sketched-Brunnen
• torus
• tstTorusModel
• tstTorusModel3