No plugins or executables installs needed, just a recent browser.

Input .OBJ and .STL.

Output, .OBJ, .VBO, .VOX, .XML, .JSON, .PNG and .STL.

reposition model

import wavefront .obj or .stl file

.obj

save as wavefront .obj file

.stl

save as binairy .stl file

.xml

save as .xml file

.json

save as .json file

.json II

save as .json II file

.vbo

save as binairy vertex buffer object (webgl)

.vox

save as .vox file

.png

save as .png image

General information

This application converts a 3D computer model representation into a voxel representation or voxel model.
The number of voxels is adjustable, so is the overall size of voxels.
In addition to standard cubes, adjustable beleveled cubes are also supported.
The calculated voxel representations can be stored and
can be used in most commercial and non-commercial 3D programmes, such as
blender,
povray or
cinema4d.

The orientation of the model on the screen does not influence the
way the voxel representation is exported.

Binairy file format VBO

VBO stand for Vertex Buffer Object. Use this
file format for WebGL.
Per vertex the following format is used.

vertex position (x) // single-precision floating-point ( 32-bit )
vertex position (y) // single-precision floating-point ( 32-bit )
vertex position (z) // single-precision floating-point ( 32-bit )
normal position (x) // single-precision floating-point ( 32-bit )
normal position (y) // single-precision floating-point ( 32-bit )
normal position (z) // single-precision floating-point ( 32-bit )
texture position (u) // single-precision floating-point ( 32-bit, not used ( = 0.0 ) )
texture position (v) // single-precision floating-point ( 32-bit, not used ( = 0.0 ) )
fake ambient occlusion bitfield // unsigned integer ( 8-bit )
fake ambient occlusion bitfield // unsigned integer ( 8-bit )
fake ambient occlusion bitfield // unsigned integer ( 8-bit )
fake ambient occlusion bitfield // unsigned integer ( 8-bit )

The fake ambient occlusion bitfield bytes are used for the custom fragment shader; see
Vertex Buffer Object

Copyrights

The generated voxel representation is free for non-commercial use.

The legolizer might be interesting for you; convert any arbitrary polygon-based 3D model into a 3D LEGO^{®} object.

Feedback

If you have any questions/remarks, please feel free to send me an e-mail.

A voxel is an enclosed three-dimensional shape, mostly a cube,
although it can be any regular, more complicated shape. Voxels are
positioned in a symmetrical/regular three-dimensional continuous
grid.
For simplicity a cube is used in the example.

To build a voxel object, you need to know whether a voxel is visible
- occupied - or invisible - empty. You can build your voxel object
manually or by using a code. This tutorial explains how to build a voxel
object by code. You need a polygon based 3D model as input.
To create a voxel object by using a code, you need to know which voxels
in the three-dimensional continuous grid contain (part of) a polygon. If
(part of) a polygon is inside, the voxel is visible, if not, the voxel
is empty.

Two dimensional

The position of a two-dimensional rectangle with a dimension of 1.0 x
1.0 ( horizontal x vertical ) can be described by using a
two-dimensional position ( x, y ). If you use the centre of the voxel as
a starting point, all the horizontal and vertical positions between -0.5
and 0.5 are related to the voxel positioned at 0.0, 0.0.

The formula is very simple: you have to round the two dimensional positions.

The horizontal and vertical dimensions of a voxel is not necessarily the
same, this may vary depending on your purpose and/or according to taste.

Three dimensional

A voxel is not two-dimensional but three-dimensional: depth is added
to the horizontal and vertical dimension. When adding depth, the same
calculations are used to convert a position into a voxel position. A
voxel position is described by using three numbers; a horizontal
position, a vertical position and a depth position.

If you want to transform your polygon-based 3D model into a voxel
representation, you need to know if (part of) the polygon lies within a
voxel. So it seems logical to think that you need a polygon cube
intersection. This requires some mathematical skills that may be
difficult to understand for most people. ...You might want to stop
reading here, but wait... if you have understood the introduction so
far, you're done; it will not become more difficult!

Normally, a polygon has three vertices. The space inside these three
vertices is the visible surface of the polygon.

A simple method to convert a polygon into voxels is soly using the
vertices of a polygon.

Each vertex is a three-dimensional position such as 13.45, 20.5,
120.0 ( x, y, z ). To find out to which voxel the vertex is related, you
need to convert the three-dimensional positions into a voxel position,
as described in the introduction.

Unless a polygon is very small, it is usually bigger than one single
voxel. To convert the complete polygon into voxels, you must subdivide
the poylgon and check whether all the vertices are related to the same
voxel. If this is the case, you can store the single voxel position and
you are done.

If the three vertices are not related to the same voxel, you must
further subdivide the already subdivided polygon and check whether all
the vertices are related to the same voxel. If not, futhter subdive the
already subdivied polygon, and so on (see image).

The process of subdividing is called recursion; the outcome of the
calculation will be used as the input for the same calculation.

In some situations, you may continue subdividing endlessly, without
getting the right outcome. Sooner or later your computer will give some
sort of warning or - worse - crash.
If the size of the (subdivided)
polygon is small enough, say one tenth of the voxel dimension, you can
stop the subdivision in order to prevent problems. Calculate the voxel
position for each individual vertex and store them separately. Instead
of one single voxel position, you have at least two, or maybe three
(adjacent) voxel positions. That's all there is to it!

By using this method, a voxel position is calculated several times so
you have to check whether the voxel position has already been
calculated. If not, store the position. If the voxel position is
calculated previously, ignore the calculated voxel position.

Storage

You have some options to store your voxel information.

You can store the voxel position as a combination of x, y and z
(floating point) numbers. Depending on your computer and operating
system, a number takes 32 or 64 bits in a memory and/or on a disk. If
you store three numbers, you need at least 3 x 32 = 96 bits... not a huge
number nowadays.

A more sophisticated way to store your voxel information is by using
individual bits; instead of 96 bits for a single voxel position you can
use the same 96 bits for up to 96 voxel positions(!) If a bit has the
value 1 - true - the voxel is present, if the value is 0 - false - the
voxel is not present. You need some extra information for this approach.
You need to number the voxel positions in your voxel universe. The
number relates to a specific bit.

For example, you have a very small voxel object, with three
horizontal voxel positions , three vertical voxel positions and three
voxel depth-positions. The total number of voxel positions in your voxel
universe equals 3 x 3 x 3, that is 27.

A real number, or so-called integer, like 234055, 12 and so is stored
as a binary number in your computer. Each bit in the binary sequence
which represent the number corresponds to a voxel position in the voxel
matrix (see image).

The first bit is related to the front left bottom voxel position, and so
on. If the value of the first bit equals 1, the voxel is present. If the
value of the bit equals 0, the voxel is not present.
Most voxel objects contain many thousands of voxel positions, so using a
more sophisticated way to store the information pays off; with a minimum
amount of data you can efficiently store your voxel data.