voxelization | This project 's aim is to voxelize the * | 3D Animation library

I am trying to write out the voxelization of a model to a Wavefront Object File.

My method is simple, and runs in reasonable time. The problem is - it produces OBJ files that are ludicrous in size. I tried to load a 1 GB file into 3D Viewer on a very respectable machine with an SSD but in some cases the delay was several seconds when trying to move the camera, in others it refused to do anything at all and effectively softlocked.

What I've done so far:

• I do not write out any faces which are internal to the model - that is, faces between two voxels which are both going to be written to the file. There's no point, as no-one can see them.
• Because OBJ does not have a widely-supported binary format (as far as I know), I found that I could save some space by trimming trailing zeros from vertex positions in the file.

The obvious space-save I don't know how to do:

• Not writing out duplicate vertices. In total, there are around 8x more vertices in the file than there should be. However, fixing this is extremely tricky because objects in Wavefront Object files do not use per-object, but global vertices. By writing out all 8 vertices each time, I always know which 8 vertices make up the next voxel. If I do not write out all 8, how do I keep track of which place in the global list I can find those 8 (if at all).

The harder, but potentially useful large space-save:

• If I could work more abstractly, there may be a way to combine voxels into fewer objects, or combine faces that lie along the same plane into larger faces. IE, if two voxels both have their front face active, turn that into one larger rectangle twice as big.

Because it's required, here's some code that roughly shows what is happening. This isn't the code that's actually in use. I can't post that, and it relies on many user-defined types and has lots of code to handle edge cases or extra functionality so would be messy and length to put up here anyways.

The only thing that's important to the question is my method - going voxel-by-voxel, writing out all 8 vertices, and then writing out whichever of the 6 sides is not neighboring an active voxel. You'll just kind of have to trust me that it works, though it does produce large files.

My question is what method or approach I can use to reduce the size further. How can I, for example, not write out any duplicate vertices?

Assumptions:

• Point is just an array of size 3, with getters like .x()
• Vector3D is a 3D wrapper around std::vector, with a .at(x,y,z) method
• Which voxels are active is arbitrary and does not follow a pattern, but is known before writeObj is called. Fetching if a voxel is active at any position is possible and fast.

I'm considering an interesting problem in which it may be possible to increase performance beyond that of a typical program by allowing kernels to write their outputs to memory without performing any synchronization.

I'm computing the voxelization from a mesh, and it is not required for the voxels on the inside of the mesh to be filled. This makes the problem simpler.

I am hoping to apply the very simple algorithm where the kernel simply computes the voxels that intersect a triangle, and dispatch the kernel on each triangle of the mesh.

My current idea is to simply have the kernel write a value to the voxels that it computes as intersecting the triangle, without applying any synchronization. It matters not to me the count of the number of triangles that a particular voxel touches, I care only that I guarantee the identification of all voxels touching any triangle.

As such the question is can I expect this simple approach to "just work" or does there exist a possible race condition in which a voxel already marked as occupied may end up getting cleared out?

If the problem is possible, then would making the store atomic (and incurring a performance hit) resolve the issue?

I need to visualize a voxelization using gnuplot.

Each voxel is of the form:

x y z [active] where [active] can be either a 1 or a 0.

The x,y,z is the relative position in a grid, so they're just integers.

An example might be:

I have coded a voxelization based raytracer which is working as expected but is very slow.

Currently the raytracer code is as follows:

NOTE: THIS QUESTION HAS BEEN DRASTICALLY EDITED FROM ITS ORIGINAL FORM

I am attempting to create a logarithmic raytracer by implementing an oct tree data structure combined with voxelization to achieve fast ray tracing.

Currently I am having issues with the ray collision detection.

The expected output should be the voxelized stanford dragon with its normal map.

Currrently the issue is that some regions are transparent:

The full dragon:

Transparent regions:

From these images it should be clear that the geometry is correct, but the collision checks are wrong.

There are 2 fragment shaders involved in this process:

I have a large set of data points in 3 column vectors. There are 10 million points with x,y,z coordinates.

I am voxelizing these points (assigning them to a discrete grid based upon occupancy). There are two ways to accomplish voxelization. The first way being a simple binning procedure where if the point falls within a certain bin that bin's intensity increases by 1. The other way is to assign a point to multiple bins and increase intensity based on distance from the bin centers. I wish to accomplish the second method of voxelization.

A simple 2d example of this is: Say you have point x,y=1.7,2.2 And have an evenly spaced grid with distance .5 between nodes in x and y.

Using method 1: The point would get binned to x,y=1.5,2 with intensity=1

Using method 2: The point would get distributed to (x,y),(x-.5,y),(x+.5,y),(x,y-.5),(x,y+.5) With intensities=(distTOpoint1/sumDistances),(distTopoint2/sumDistances),...,(distTopoint5/sumDistances)

I'm currently looking into an algorithm described within this research paper, however I've come across a portion which I'm unclear of how it's been achieved.

A grid is defined by placing a camera above the scene and adjusting its view frustum to enclose the area to be voxelized. This camera has an associated viewport with (w, h ) dimensions. The scene is then rendered, constructing the voxelization in the frame buffer. A pixel (i,j) represents a column in the grid and each voxel within this column is binary encoded using the k th bit of the RGBA value of the pixel. Therefore, the corresponding image represents a w×h×32 grid with one bit of information per voxel. This bit indicates whether a primitive passes through a cell or not. The union of voxels corresponding to the kth bit for all pixels defines a slice. Consequently, the image/texture encoding the grid is called a slicemap . When a primitive is rasterized, a set of fragments are obtained. A fragment shader is used in order to determine the position of the fragment in the column based on its depth. The result is then OR−ed with the current value of the frame buffer.

Presumably one would achieve this by setting the blend equation to use a binary-OR, however that's not an available option and I can't see a way to achieve it through manipulation of glBlendFunc()+glBlendEquation()

Additionally from my understanding it's not possible to read the framebuffer within the fragment shader. You can bind a texture to both the shader and framebuffer, however accessing this within the shader is undefined behaviour due to a lack of synchronisation.

The paper doesn't state whether OpenGL or Direct-X was used, however to the best of my understanding it has the same glBlendEquation() limitations.

Am I missing something?

I realise I could simply achieve the same result in 32 passes.