The cl-voxelize Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-voxelize Reference Manual

This is the cl-voxelize Reference Manual, version 0.1, generated automatically by Declt version 2.3 "Robert April" on Tue Jan 09 14:07:41 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

cl-voxelize

Build Status Coverage Status

Cl-voxelize is a library to convert polygon models into voxel models for particle-based physics simulation.

Example

Here shows an example of how to use cl-voxelize. With the Stanford bunny's ply file, I illustrate how to load, voxelize and visualize it.

As an example data, use the Stanford bunny's ply file from the Stanford 3D Scanning Repository. Since the voxelization algorithm I adopt does not work well for polygon model with holes, I use Stanfords's Volfill tool for hole filling. Additionally, I simplify the model with QSlim for reducing voxelization time. This simplification make no effect on the result voxels in this case, because relatively coarse resolution is enough for particle-based simulation. A hole-filled and simplified Stanford bunny's ply file is placed in this repository.

A hole-filled and simplified Stanford bunny in PLY format:

Read the Stanford bunny's .ply file and convert it to a list of triangles which is input to voxelize function.

(defun triangles (vertices faces)
  ;; make a list of triangles from vertex array and face array
  (let (ret)
    (dotimes (i (array-dimension faces 0))
      (let ((face (aref faces i)))
        (let ((v0 (aref vertices (nth face 0)))
              (v1 (aref vertices (nth face 1)))
              (v2 (aref vertices (nth face 2))))
          (push (list v0 v1 v2) ret))))
    ret))

(defun ply-to-triangles (path)
  (cl-ply:with-ply-for-reading (plyfile path)
    (let ((vertices (make-array (cl-ply:ply-element-size plyfile "vertex")))
          (faces (make-array (cl-ply:ply-element-size plyfile "face"))))
      ;; read vertices
      (loop repeat (array-dimension vertices 0)
            for i from 0
         do (setf (aref vertices i)
                  (cl-ply:ply-read-element plyfile "vertex")))
      ;; read faces
      (loop repeat (array-dimension faces 0)
            for i from 0
         do (setf (aref faces i)
                  (car (cl-ply:ply-read-element plyfile "face"))))
      ;; get triangles from vertices and faces
      (triangles vertices faces))))

Voxelize the obtained triangles and get voxels as the result. The voxels are represented as a list of their center points.

(let ((triangles (ply-to-triangles "/path/to/bunny.ply"))
      (delta 0.0045))
  (voxelize triangles delta))

As an illustration, I show you the result voxels rendered with POV-Ray.

Voxelized Stanford bunny

Installation

You can install cl-voxelize via Quicklisp:

(ql:quickload :cl-voxelize)

API

[Function] voxelize

VOXELIZE triangles delta &optional antialias-p => voxels

Returns voxels with given triangles which is a list of triangles. delta is a floating point which specifies the resolution of voxels. voxels is represented as a list of voxels' center points. If antialias-p is true, the result is antialiased.

[Macro] do-voxelize

DO-VOXELIZE ((x y z) triangles delta &optional antialias-p) &body body => result

do-voxelize is a voxelize's counterpart in do- style. Voxels' center points are bound to x, y and z symbols.

FAQ

Q. What are file formats to be voxelized?

A. Any file formats are supported as far as they can be converted to fit cl-voxelize's API interface.

Q. How large polygon model? How long does it take to voxelize?

A. Currently I do not set performance goal because relatively coarse resolution is enough for particle-based simulation.

Q. Are there any restrictions for polygon models to be voxelized?

A. The voxelization algorithm I adopt does not work well for polygon models with holes.

Q. In a quadtree used in this implementation, how is a triangle which intersects with multiple sub-quadtrees treated?

A. There are roughly two options how to treat a triangle which intersects with multiple sub-quadtrees:

To properly determine inside/outside in this case, I choose the former.

Q. If a ray goes on a shared side of triangles through, is inside/outside rightly determined?

A. To determine inside/outside in such case, duplicated intersections are removed.

Q. What are tools used to make the Stanford bunny's ply file in Example section?

A. Tools I used were following:

Reference

Author

Copyright

Copyright (c) 2014 Masayuki Takagi (kamonama@gmail.com)

License

Licensed under the LLGPL License.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-voxelize

Author

Masayuki Takagi

License

LLGPL

Description

Convert polygon models into voxel models for particle-based physics simulation.

Long Description

# cl-voxelize

[![Build Status](https://travis-ci.org/takagi/cl-voxelize.svg)](https://travis-ci.org/takagi/cl-voxelize)
[![Coverage Status](https://coveralls.io/repos/takagi/cl-voxelize/badge.svg)](https://coveralls.io/r/takagi/cl-voxelize)

Cl-voxelize is a library to convert polygon models into voxel models for particle-based physics simulation.

## Example

Here shows an example of how to use cl-voxelize. With the Stanford bunny’s ply file, I illustrate how to load, voxelize and visualize it.

As an example data, use the Stanford bunny’s ply file from [the Stanford 3D Scanning Repository](https://graphics.stanford.edu/data/3Dscanrep/). Since the voxelization algorithm I adopt does not work well for polygon model with holes, I use Stanfords’s [Volfill](http://graphics.stanford.edu/software/volfill/) tool for hole filling. Additionally, I simplify the model with [QSlim](http://www.cs.cmu.edu/afs/cs/Web/People/garland/quadrics/qslim.html) for reducing voxelization time. This simplification make no effect on the result voxels in this case, because relatively coarse resolution is enough for particle-based simulation. A hole-filled and simplified Stanford bunny’s ply file is placed in this repository.

A hole-filled and simplified Stanford bunny in PLY format:
* https://github.com/takagi/cl-voxelize/blob/master/examples/bunny.ply

Read the Stanford bunny’s .ply file and convert it to a list of triangles which is input to ‘voxelize‘ function.

(defun triangles (vertices faces)
;; make a list of triangles from vertex array and face array
(let (ret)
(dotimes (i (array-dimension faces 0))
(let ((face (aref faces i)))
(let ((v0 (aref vertices (nth face 0)))
(v1 (aref vertices (nth face 1)))
(v2 (aref vertices (nth face 2))))
(push (list v0 v1 v2) ret))))
ret))

(defun ply-to-triangles (path)
(cl-ply:with-ply-for-reading (plyfile path)
(let ((vertices (make-array (cl-ply:ply-element-size plyfile "vertex")))
(faces (make-array (cl-ply:ply-element-size plyfile "face"))))
;; read vertices
(loop repeat (array-dimension vertices 0)
for i from 0
do (setf (aref vertices i)
(cl-ply:ply-read-element plyfile "vertex")))
;; read faces
(loop repeat (array-dimension faces 0)
for i from 0
do (setf (aref faces i)
(car (cl-ply:ply-read-element plyfile "face"))))
;; get triangles from vertices and faces
(triangles vertices faces))))

Voxelize the obtained triangles and get voxels as the result. The voxels are represented as a list of their center points.

(let ((triangles (ply-to-triangles "/path/to/bunny.ply"))
(delta 0.0045))
(voxelize triangles delta))

As an illustration, I show you the result voxels rendered with POV-Ray.

![Voxelized Stanford bunny](https://raw.githubusercontent.com/takagi/cl-voxelize/master/examples/bunny.png)

## Installation

You can install cl-voxelize via Quicklisp:

(ql:quickload :cl-voxelize)

## API

### [Function] voxelize

VOXELIZE triangles delta &optional antialias-p => voxels

Returns ‘voxels‘ with given ‘triangles‘ which is a list of triangles. ‘delta‘ is a floating point which specifies the resolution of voxels. ‘voxels‘ is represented as a list of voxels’ center points. If ‘antialias-p‘ is true, the result is antialiased.

### [Macro] do-voxelize

DO-VOXELIZE ((x y z) triangles delta &optional antialias-p) &body body => result

‘do-voxelize‘ is a ‘voxelize‘’s counterpart in ‘do-‘ style. Voxels’ center points are bound to ‘x‘, ‘y‘ and ‘z‘ symbols.

## FAQ

**Q. What are file formats to be voxelized?**

A. Any file formats are supported as far as they can be converted to fit cl-voxelize’s API interface.

**Q. How large polygon model? How long does it take to voxelize?**

A. Currently I do not set performance goal because relatively coarse resolution is enough for particle-based simulation.

**Q. Are there any restrictions for polygon models to be voxelized?**

A. The voxelization algorithm I adopt does not work well for polygon models with holes.

**Q. In a quadtree used in this implementation, how is a triangle which intersects with multiple sub-quadtrees treated?**

A. There are roughly two options how to treat a triangle which intersects with multiple sub-quadtrees:
* A triangle belongs to all sub-quadtrees with which it intersects
* A triangle belongs to only one of sub-quadtrees with which it intersects

To properly determine inside/outside in this case, I choose the former.

**Q. If a ray goes on a shared side of triangles through, is inside/outside rightly determined?**

A. To determine inside/outside in such case, duplicated intersections are removed.

**Q. What are tools used to make the Stanford bunny’s ply file in Example section?**

A. Tools I used were following:
* [ply2vri](http://grail.cs.washington.edu/software-data/ply2vri/) - a simple command line tool for converting triangle meshes in PLY format into signed-distance volumetric grids in VRI format
* [Volfill](http://graphics.stanford.edu/software/volfill/) - a program for filling in holes in dense polygon meshes using an algorithm based on volumetric diffusion
* [VRIP](http://graphics.stanford.edu/software/vrip/) - to convert a VRI file to a new triangle mesh in PLY format using the embedding implementation of Marching Cubes
* [QSlim](http://www.cs.cmu.edu/afs/cs/Web/People/garland/quadrics/qslim.html) - a program to simplify polygon model with QEM(Quadratic Error Metric)
* [Blender](http://www.blender.org/) - just for converting PLY format from/to OBJ format to apply QSlim

## Reference

* S. Thon, G. Gresquiere, and R. Raffin. "A low cost antialiased space filled voxelization of polygonal objects."

## Author

* Masayuki Takagi (kamonama@gmail.com)

## Copyright

Copyright (c) 2014 Masayuki Takagi (kamonama@gmail.com)

## License

Licensed under the LLGPL License.

Version

0.1

Dependency

alexandria

Source

cl-voxelize.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 cl-voxelize/src

Parent

cl-voxelize (system)

Location

src/

Component

cl-voxelize.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 cl-voxelize.asd

Location

cl-voxelize.asd

Systems

cl-voxelize (system)

Packages

cl-voxelize-asd


Previous: , Up: Lisp files   [Contents][Index]

4.1.2 cl-voxelize/src/cl-voxelize.lisp

Parent

src (module)

Location

src/cl-voxelize.lisp

Packages

cl-voxelize

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 cl-voxelize-asd

Source

cl-voxelize.asd

Use List

Previous: , Up: Packages   [Contents][Index]

5.2 cl-voxelize

Source

cl-voxelize.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Macros

Macro: do-voxelize ((X Y Z) TRIANGLES DELTA &key ANTIALIAS-P) &body BODY
Package

cl-voxelize

Source

cl-voxelize.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Functions

Function: voxelize TRIANGLES DELTA &key ANTIALIAS-P
Package

cl-voxelize

Source

cl-voxelize.lisp (file)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *inside-eps*
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Special Variable: *max-capacity*
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Special Variable: *max-depth*
Package

cl-voxelize

Source

cl-voxelize.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: with-triangle ((X0 Y0 Z0) (X1 Y1 Z1) (X2 Y2 Z2)) TRIANGLE &body BODY
Package

cl-voxelize

Source

cl-voxelize.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: %%do-voxelize FN TRIANGLES DELTA
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: %%do-voxelize-antialias FN TRIANGLES DELTA
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: %do-voxelize FN TRIANGLES DELTA ANTIALIAS-P
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: %empty-quadtree X0 Y0 X1 Y1 DEPTH
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: %make-quadtree &key (TRIANGLES TRIANGLES) (NW NW) (NE NE) (SW SW) (SE SE) (BOUNDARY BOUNDARY) (DEPTH DEPTH)
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: copy-quadtree INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: devide-quadtree QUADTREE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: empty-quadtree X0 Y0 X1 Y1
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: insert-quadtree QUADTREE TRIANGLE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: inside-p Z INTERSECTIONS-Z
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: intersection-z X Y TRIANGLE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: intersections-z X Y TRIANGLES
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: or! &rest ARGS
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: point-intersect-p BOUNDARY X Y
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree TRIANGLES
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-boundary INSTANCE
Function: (setf quadtree-boundary) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-depth INSTANCE
Function: (setf quadtree-depth) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-leaf-p QUADTREE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-max-capacity-p QUADTREE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-max-depth-p QUADTREE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-ne INSTANCE
Function: (setf quadtree-ne) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-node-p QUADTREE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-nw INSTANCE
Function: (setf quadtree-nw) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-p OBJECT
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-root-p QUADTREE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-se INSTANCE
Function: (setf quadtree-se) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-sw INSTANCE
Function: (setf quadtree-sw) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: quadtree-triangles INSTANCE
Function: (setf quadtree-triangles) VALUE INSTANCE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: query-quadtree QUADTREE X Y
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: triangle-bounding-box TRIANGLE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: triangle-intersect-p BOUNDARY TRIANGLE
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Function: triangles-bounding-box TRIANGLES
Package

cl-voxelize

Source

cl-voxelize.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Structures

Structure: quadtree ()
Package

cl-voxelize

Source

cl-voxelize.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: triangles
Readers

quadtree-triangles (function)

Writers

(setf quadtree-triangles) (function)

Slot: nw
Readers

quadtree-nw (function)

Writers

(setf quadtree-nw) (function)

Slot: ne
Readers

quadtree-ne (function)

Writers

(setf quadtree-ne) (function)

Slot: sw
Readers

quadtree-sw (function)

Writers

(setf quadtree-sw) (function)

Slot: se
Readers

quadtree-se (function)

Writers

(setf quadtree-se) (function)

Slot: boundary
Readers

quadtree-boundary (function)

Writers

(setf quadtree-boundary) (function)

Slot: depth
Readers

quadtree-depth (function)

Writers

(setf quadtree-depth) (function)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
cl-voxelize.asd: The cl-voxelize<dot>asd file
cl-voxelize/src: The cl-voxelize/src module
cl-voxelize/src/cl-voxelize.lisp: The cl-voxelize/src/cl-voxelize<dot>lisp file

F
File, Lisp, cl-voxelize.asd: The cl-voxelize<dot>asd file
File, Lisp, cl-voxelize/src/cl-voxelize.lisp: The cl-voxelize/src/cl-voxelize<dot>lisp file

L
Lisp File, cl-voxelize.asd: The cl-voxelize<dot>asd file
Lisp File, cl-voxelize/src/cl-voxelize.lisp: The cl-voxelize/src/cl-voxelize<dot>lisp file

M
Module, cl-voxelize/src: The cl-voxelize/src module

Jump to:   C   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
C   D   E   F   I   M   O   P   Q   T   V   W  
Index Entry  Section

%
%%do-voxelize: Internal functions
%%do-voxelize-antialias: Internal functions
%do-voxelize: Internal functions
%empty-quadtree: Internal functions
%make-quadtree: Internal functions

(
(setf quadtree-boundary): Internal functions
(setf quadtree-depth): Internal functions
(setf quadtree-ne): Internal functions
(setf quadtree-nw): Internal functions
(setf quadtree-se): Internal functions
(setf quadtree-sw): Internal functions
(setf quadtree-triangles): Internal functions

C
copy-quadtree: Internal functions

D
devide-quadtree: Internal functions
do-voxelize: Exported macros

E
empty-quadtree: Internal functions

F
Function, %%do-voxelize: Internal functions
Function, %%do-voxelize-antialias: Internal functions
Function, %do-voxelize: Internal functions
Function, %empty-quadtree: Internal functions
Function, %make-quadtree: Internal functions
Function, (setf quadtree-boundary): Internal functions
Function, (setf quadtree-depth): Internal functions
Function, (setf quadtree-ne): Internal functions
Function, (setf quadtree-nw): Internal functions
Function, (setf quadtree-se): Internal functions
Function, (setf quadtree-sw): Internal functions
Function, (setf quadtree-triangles): Internal functions
Function, copy-quadtree: Internal functions
Function, devide-quadtree: Internal functions
Function, empty-quadtree: Internal functions
Function, insert-quadtree: Internal functions
Function, inside-p: Internal functions
Function, intersection-z: Internal functions
Function, intersections-z: Internal functions
Function, or!: Internal functions
Function, point-intersect-p: Internal functions
Function, quadtree: Internal functions
Function, quadtree-boundary: Internal functions
Function, quadtree-depth: Internal functions
Function, quadtree-leaf-p: Internal functions
Function, quadtree-max-capacity-p: Internal functions
Function, quadtree-max-depth-p: Internal functions
Function, quadtree-ne: Internal functions
Function, quadtree-node-p: Internal functions
Function, quadtree-nw: Internal functions
Function, quadtree-p: Internal functions
Function, quadtree-root-p: Internal functions
Function, quadtree-se: Internal functions
Function, quadtree-sw: Internal functions
Function, quadtree-triangles: Internal functions
Function, query-quadtree: Internal functions
Function, triangle-bounding-box: Internal functions
Function, triangle-intersect-p: Internal functions
Function, triangles-bounding-box: Internal functions
Function, voxelize: Exported functions

I
insert-quadtree: Internal functions
inside-p: Internal functions
intersection-z: Internal functions
intersections-z: Internal functions

M
Macro, do-voxelize: Exported macros
Macro, with-triangle: Internal macros

O
or!: Internal functions

P
point-intersect-p: Internal functions

Q
quadtree: Internal functions
quadtree-boundary: Internal functions
quadtree-depth: Internal functions
quadtree-leaf-p: Internal functions
quadtree-max-capacity-p: Internal functions
quadtree-max-depth-p: Internal functions
quadtree-ne: Internal functions
quadtree-node-p: Internal functions
quadtree-nw: Internal functions
quadtree-p: Internal functions
quadtree-root-p: Internal functions
quadtree-se: Internal functions
quadtree-sw: Internal functions
quadtree-triangles: Internal functions
query-quadtree: Internal functions

T
triangle-bounding-box: Internal functions
triangle-intersect-p: Internal functions
triangles-bounding-box: Internal functions

V
voxelize: Exported functions

W
with-triangle: Internal macros

Jump to:   %   (  
C   D   E   F   I   M   O   P   Q   T   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
B   D   N   S   T  
Index Entry  Section

*
*inside-eps*: Internal special variables
*max-capacity*: Internal special variables
*max-depth*: Internal special variables

B
boundary: Internal structures

D
depth: Internal structures

N
ne: Internal structures
nw: Internal structures

S
se: Internal structures
Slot, boundary: Internal structures
Slot, depth: Internal structures
Slot, ne: Internal structures
Slot, nw: Internal structures
Slot, se: Internal structures
Slot, sw: Internal structures
Slot, triangles: Internal structures
Special Variable, *inside-eps*: Internal special variables
Special Variable, *max-capacity*: Internal special variables
Special Variable, *max-depth*: Internal special variables
sw: Internal structures

T
triangles: Internal structures

Jump to:   *  
B   D   N   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   P   Q   S  
Index Entry  Section

C
cl-voxelize: The cl-voxelize system
cl-voxelize: The cl-voxelize package
cl-voxelize-asd: The cl-voxelize-asd package

P
Package, cl-voxelize: The cl-voxelize package
Package, cl-voxelize-asd: The cl-voxelize-asd package

Q
quadtree: Internal structures

S
Structure, quadtree: Internal structures
System, cl-voxelize: The cl-voxelize system

Jump to:   C   P   Q   S