Hubbry Logo
VoxelVoxelMain
Open search
Voxel
Community hub
Voxel
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Voxel
Voxel
Voxel
View on Wikipedia
from Wikipedia
A set of voxels in a stack, with a single voxel shaded
Illustration of a voxel grid containing color values
Part of a series on
Video game graphics
Types
Topics
Lists

In computing, a voxel is a representation of a value on a three-dimensional regular grid, akin to the two-dimensional pixel. Voxels are frequently used in the visualization and analysis of medical and scientific data (e.g. geographic information systems (GIS)).[1] Voxels also have technical and artistic applications in video games, largely originating with surface rendering in Outcast (1999). Minecraft (2011) makes use of an entirely voxelated world to allow for a fully destructible and constructable environment.[2] Voxel art, of the sort used in Minecraft and elsewhere, is a style and format of 3D art analogous to pixel art.

As with pixels in a 2D bitmap, voxels themselves do not typically have their position (i.e. coordinates) explicitly encoded with their values. Instead, rendering systems infer the position of a voxel based upon its position relative to other voxels (i.e., its position in the data structure that makes up a single volumetric image). Some volumetric displays use voxels to describe their resolution. For example, a cubic volumetric display might be able to show 512×512×512 (or about 134 million) voxels.

In contrast to pixels and voxels, polygons are often explicitly represented by the coordinates of their vertices (as points). A direct consequence of this difference is that polygons can efficiently represent simple 3D structures with much empty or homogeneously filled space, while voxels excel at representing regularly sampled spaces that are non-homogeneously filled.

One of the definitions is:

Voxel is an image of a three-dimensional space region limited by given sizes, which has its own nodal point coordinates in an accepted coordinate system, its own form, its own state parameter that indicates its belonging to some modeled object, and has properties of modeled region.

This definition has the following advantage. If fixed voxel form is used within the whole model it is much easier to operate with voxel nodal points (i.e. three coordinates of this point). Yet, there is the simple form of record: indexes of the elements in the model set (i.e. integer coordinates). Model set elements in this case are state parameters, indicating voxel belonging to the modeled object or its separate parts, including their surfaces.[3]

Etymology

[edit]

The word voxel originated by analogy to "pixel", with vo representing "volume" (instead of pixel's "picture") and el representing "element";[4] a similar formation with el for "element" is the word "texel".[4] The term hypervoxel is a generalization of voxel for higher-dimensional spaces.[5]

Rendering

[edit]

A volume described as voxels can be visualized either by direct volume rendering or by the extraction of polygon iso-surfaces that follow the contours of given threshold values. The marching cubes algorithm is often used for iso-surface extraction, however other methods exist as well.

Both ray tracing and ray casting, as well as rasterisation, can be applied to voxel data to obtain 2D raster graphics to depict on a monitor.

Incremental error rasterisation

[edit]

Another technique for voxels involves raster graphics where one simply raytraces every pixel of the display into the scene, tracking an error term to determine when to step. A typical implementation will raytrace each pixel of the display starting at the bottom of the screen using what is known as a y-buffer. When a voxel is reached that has a higher y value on the display it is added to the y-buffer overriding the previous value and connected with the previous y-value on the screen interpolating the color values. There is a major downside to voxel rasterization when transformation is applied which causes severe aliasing. The advantage was the ability to rasterise using cheap integer calculations on a CPU without hardware acceleration.[6]

Outcast, and other 1990s video games employed this graphics technique for effects such as reflection and bump-mapping and usually for terrain rendering. Outcast's graphics engine was mainly a combination of a ray casting (heightmap) engine, used to render the landscape, and a texture mapping polygon engine used to render objects. The "Engine Programming" section of the game's credits in the manual has several subsections related to graphics, among them: "Landscape Engine", "Polygon Engine", "Water & Shadows Engine" and "Special effects Engine".[7] Although Outcast is often cited as a forerunner of voxel technology,[8] this is somewhat misleading. The game does not actually model three-dimensional volumes of voxels. Instead, it models the ground as a surface, which may be seen as being made up of voxels. The ground is decorated with objects that are modeled using texture-mapped polygons. When Outcast was developed, the term "voxel engine", when applied to computer games, commonly referred to a ray casting engine (for example the Voxel Space engine). On the engine technology page of the game's website, the landscape engine is also referred to as the "Voxels engine".[9] The engine is purely software-based: it does not rely on hardware-acceleration via a 3D graphics card.[10]

John Carmack also experimented with voxels for the Quake III Arena engine.[11] One such problem cited by Carmack was the lack of graphics cards designed specifically for such rendering requiring them to be software rendered.

Comanche was also the first commercial flight simulation based on voxel technology. NovaLogic used the proprietary Voxel Space engine developed for the company by Kyle Freeman[12] (written entirely in Assembly language) to create open landscapes.[13] This rendering technique allowed for much more detailed and realistic terrain compared to simulations based on vector graphics at that time.[10]

[edit]
  • 3D rendering of a μCT scan of a leaf piece, resolution circa 40 μm/voxel when viewed at the full size
  • A (smoothed) rendering of a data set of voxels for a macromolecule
    A (smoothed) rendering of a data set of voxels for a macromolecule

Data

[edit]

A voxel represents a single sample, or data point, on a regularly spaced, three-dimensional grid. This data point can consist of a single piece of data, such as an opacity, or multiple pieces of data, such as a color in addition to opacity. A voxel represents only a single point on this grid, not a volume; the space between each voxel is not represented in a voxel-based dataset. Depending on the type of data and the intended use for the dataset, this missing information may be reconstructed and/or approximated, e.g. via interpolation.

In computed tomography (abdominal CT pictured), voxels are generated by multiplying the field of view (FOV) by the scan range.

The value of a voxel may represent various properties. In CT scans, the values are Hounsfield units, giving the opacity of material to X-rays.[14]: 29  Different types of value are acquired from MRI or ultrasound.

Voxels can contain multiple scalar values, essentially vector (tensor) data; in the case of ultrasound scans with B-mode and Doppler data, density, and volumetric flow rate are captured as separate channels of data relating to the same voxel positions.

While voxels provide the benefit of precision and depth of reality, they are typically large data sets and are unwieldy to manage given the bandwidth of common computers. However, through efficient compression and manipulation of large data files, interactive visualization can be enabled on consumer market computers.

Other values may be useful for immediate 3D rendering, such as a surface normal vector and color.

Technologies to extend voxels into 4 and 5 dimensions of data are under investigation.[15]

Uses

[edit]

Uses of voxels include volumetric imaging in medicine and representation of terrain in games and simulations. Voxel terrain is used instead of a heightmap because of its ability to represent overhangs, caves, arches, and other 3D terrain features. These concave features cannot be represented in a heightmap due to only the top 'layer' of data being represented, leaving everything below it filled (the volume that would otherwise be the inside of the caves, or the underside of arches or overhangs).

Computer games

[edit]

Editors

[edit]

While scientific volume visualization does not require modifying the actual voxel data, voxel editors can be used to create art (especially 3D pixel art) and models for voxel based games. Some editors are focused on a single approach to voxel editing while others mix various approaches. Some common approaches are:

  • Slice based: The volume is sliced in one or more axes and the user can edit each image individually using 2D raster editor tools. These generally store color information in voxels.
  • Sculpture: Similar to the vector counterpart but with no topology constraints. These usually store density information in voxels and lack color information.
  • Building blocks: The user can add and remove blocks just like a construction set toy.

There are a few voxel editors available that are not tied to specific games or engines. They can be used as alternatives or complements to traditional 3D vector modeling.

Extensions

[edit]

A generalization of a voxel is the toxel, or temporal voxel.[28] This is used in the case of a 4D dataset, for example, an image sequence that represents 3D space together with another dimension such as time. In this way, an image could contain 100×100×100×100 voxels, which could be seen as a series of 100 frames of a 100×100×100 volume image (the equivalent for a 3D image would be showing a 2D cross section of the image in each frame). Although storage and manipulation of such data requires large amounts of memory, it allows the representation and analysis of spacetime systems.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Voxel

View on Grokipedia
from Grokipedia
A voxel, short for "," is the three-dimensional analogue of a two-dimensional , representing a discrete value—such as color, , or opacity—on a in . The term originated as a portmanteau of "" and "element" and was first documented in 1976 during discussions on computer-aided . As a fundamental unit in volumetric data structures, a voxel typically occupies a cubic defined by coordinates, enabling the of continuous 3D volumes into manageable computational elements. Voxels play a central role in and scientific visualization, where they facilitate volume rendering techniques to display complex internal structures without relying on surface meshes. In medical imaging, such as computed tomography (CT) and magnetic resonance imaging (MRI), voxels encode tissue densities or signal intensities, allowing for accurate 3D reconstructions of anatomical features and aiding in diagnostics, surgical planning, and radiation therapy simulations. Their grid-based nature also supports efficient algorithms for segmentation, registration, and analysis of volumetric datasets in fields like neuroscience and radiology. Beyond visualization, voxels find applications in and additive manufacturing, where they define printable volume elements to create intricate, lattice-like structures with precise material properties at the micro-scale. In video games and simulations, voxel representations enable procedural terrain generation, destructible environments, and physics-based interactions, as seen in titles employing voxel engines for dynamic worlds. Emerging uses extend to geophysical modeling, robotics for obstacle avoidance, and artificial intelligence for processing point cloud data, highlighting voxels' versatility in handling spatial information across disciplines.

Fundamentals

Definition

A voxel is a portmanteau of "" and "element," serving as the three-dimensional analog to a two-dimensional by representing a value on a in . This value typically encodes properties such as density, color, or material type, allowing voxels to model volumetric data in fields like and scientific visualization. Key characteristics of a voxel include its position within a regular cubic lattice, where each voxel occupies a discrete cell defined by integer coordinates, and its association with scalar or vector data that captures spatial information. This structure enables the representation of 3D spatial occupancy, where filled voxels indicate occupied volume and empty ones denote voids, facilitating uniform sampling of continuous 3D fields. Mathematically, a voxel at coordinates (x,y,z)(x, y, z) holds a value v(x,y,z)v(x,y,z), commonly stored in a 3D array of dimensions N×M×PN \times M \times P, where NN, MM, and PP define the grid resolution along each axis. Unlike polygonal meshes, which approximate surfaces using connected vertices, edges, and faces for efficient rendering of complex geometries, voxels employ a discrete, grid-based approach that excels in of volumes but can become memory-intensive for high-resolution representations of intricate shapes. This grid underpins interpolation techniques, such as , essential for reconstructing continuous fields from voxel data in subsequent rendering and analysis processes.

Etymology

The term "voxel" originated as a portmanteau of "volume" and "element," formed by analogy to "pixel" (short for "picture element") to denote a fundamental unit of three-dimensional space. This linguistic construction underscores the discretization of volumetric data, extending the two-dimensional pixel concept to higher dimensions for representing finite volumes in digital processing. The earliest documented use of "voxel" appeared in 1976 within the Proceedings of the Symposium on Computer-Aided Diagnosis of Medical Images, where it described volumetric units in the context of digital medical imaging. Subsequent early applications emerged in three-dimensional imaging literature during the late , particularly in medical diagnostics and . The terminology evolved from the more verbose "volume element" to "voxel" for conciseness as 3D digital processing matured in the . This facilitated efficient communication in technical fields, while distinguishing "voxel" from related terms like "texel" (texture element, for surface mapping) and "pixel" (two-dimensional picture element), thereby emphasizing its unique focus on volumetric . Rosenfeld's 1981 work on digital topology further popularized the term by explicitly defining voxels as shorthand for s in 3D picture analysis.

Historical Development

The foundations of voxel technology trace back to the 1960s, when pioneering work in laid the groundwork for volumetric representations. Ivan Sutherland's development of in 1963 introduced interactive graphics on the TX-2 computer, enabling the manipulation of line drawings and marking the birth of modern , which later extended to concepts essential for handling volume elements. Concurrently, in , the invention of the first computed (CT) scanner in 1972 by produced cross-sectional slices that, when stacked, formed early volumetric datasets, revolutionizing the visualization of internal body structures through aggregated 2D data. The 1970s and saw formalization and practical adoption of voxels. The term "voxel" first appeared in the 1976 Proceedings of the Symposium on of Medical Images, establishing it as the 3D analog to the pixel in image processing and . By the , voxel-based reconstructions became integral to CT and (MRI), with early techniques enabling the synthesis of 3D images from data sampled in voxels; a seminal contribution was Marc Levoy's 1988 paper on displaying surfaces from volume data, which introduced methods for efficient visualization of medical scans. Scientific visualization software further advanced this era, exemplified by Vital Images' Voxel View in 1989, which allowed interactive rendering of volumetric datasets from CT and MRI for applications in and . The marked a surge in voxel integration into consumer applications, particularly gaming, where hardware limitations favored volumetric techniques over polygons. The Comanche series, starting with Comanche: Maximum Overkill in 1992, employed the engine for terrain rendering, using heightfield-based to generate detailed 3D landscapes in real-time flight simulations. Experiments in during this decade, such as specialized rasterizers, optimized voxel processing for interactive displays, bridging scientific and entertainment domains. From the 2000s onward, voxels experienced widespread adoption driven by computational advances. The 2011 release of Minecraft popularized procedural voxel worlds, enabling user-generated 3D environments composed of discrete blocks and sparking indie game development. GPU-optimized rendering techniques in the 2000s facilitated faster volume traversal and shading, enhancing real-time applications. In the 2020s, real-time voxel engines have advanced virtual reality (VR), supporting immersive simulations with dynamic lighting and destruction. Key modern contributors include Sean Barrett, whose stb_voxel_render library (2015) provides efficient single-file implementations for mesh generation from voxel data, influencing open-source tools.

Data Representation

Basic Structures

The primary structure for storing voxel data is a dense three-dimensional grid represented as a multi-dimensional , where each element corresponds to a voxel at coordinates (x, y, z) within the defined bounds. This approach suits uniform, fully populated volumes, such as those in or simple , by enabling direct spatial mapping without sparsity overhead. In languages like C++, this can be implemented as a nested vector structure, such as std::vector<std::vector<std::vector<T>>>, where T denotes the voxel's (e.g., unsigned char for scalar intensity or struct for color). To optimize memory access and cache performance, especially in hardware-accelerated environments, the 3D is often flattened into a one-dimensional using row-major ordering. The index i for a voxel at (x, y, z) in a grid of width W and H is calculated as:

i = x + y \cdot W + z \cdot W \cdot H

i = x + y \cdot W + z \cdot W \cdot H

This facilitates contiguous storage and efficient traversal in GPU shaders or parallel processing. Voxel data is commonly persisted in raw formats, which store the grid as unencoded byte sequences preceded by a header specifying essential metadata. Formats like .rawvol or generic .raw files include headers detailing the grid dimensions (e.g., X, Y, Z sizes in voxels), (such as 8-bit unsigned for scalar values representing or 24-bit RGB for color), and byte order to ensure . The .vox format, popularized by tools like MagicaVoxel, extends this with a chunk-based structure: a main header for version and size, followed by SIZE chunks for dimensions and XYZI chunks packing voxel positions and colors in a compact binary layout, supporting both scalar and palette-indexed RGB data. These formats prioritize simplicity, with headers typically 20-100 bytes, allowing direct memory mapping for loading without decompression. Memory usage for a dense voxel grid follows a space complexity of O(N \cdot M \cdot P), where N, M, P are the dimensions in voxels, multiplied by the size of each voxel's data (e.g., 1 byte for 8-bit scalars yields 1 GB for a 1000^3 grid). Access patterns emphasize locality, such as nearest-neighbor lookups for , which query adjacent voxels via offset calculations in the (e.g., (x+1, y, z) at i+1 in flattened form). Cross-platform compatibility requires explicit handling in headers and loaders, as little-endian (common on x86) versus big-endian (e.g., some network protocols) can corrupt multi-byte values like 24-bit colors; tools like ITK enforce byte-swapping based on header flags during import. Basic operations on voxel grids include traversal algorithms for region processing and slicing for visualization. (BFS), implemented via a queue, enables by starting from a seed voxel and propagating to 6-connected neighbors (sharing a face), updating properties like or material in a level-order manner to approximate distance or occlusion. This is efficient for dense grids, with O(volume) in the worst case. Slicing extracts 2D projections by selecting a fixed coordinate plane (e.g., all voxels where z = k) or aggregating along an axis, such as summing intensities for a maximum projection , which reduces the 3D to a 2D matrix for rendering or analysis.

Advanced Structures and Compression

Advanced structures for voxel data leverage hierarchical partitioning and encoding schemes to handle sparsity and repetition, enabling efficient storage and access in large volumes. Unlike dense arrays, these methods prioritize non-uniform distributions common in real-world data, such as in simulations or uniform regions in scans. (RLE) is a technique particularly suited for voxel volumes with uniform or repetitive regions, where sequences of identical voxel values are represented as pairs of (value, length). This approach excels in sparse or repetitive datasets, like or fluid simulations, by exploiting spatial coherency to reduce without loss of . For instance, in volumetric animations of running , RLE applied to key-frames achieves compression ratios of up to 30:1, while difference frames for in-betweens yield even higher ratios around 400:1, resulting in overall animation compression of approximately 100:1. Hierarchical structures like s and kd-trees facilitate non-uniform access by partitioning the 3D space into subdivided nodes based on occupancy or geometric features. An divides a cubic volume into eight child nodes recursively, storing only populated branches to compress empty space, with each internal node typically having up to eight children. Kd-trees, in contrast, use binary splits along alternating axes (k=3 for 3D), enabling adaptive partitioning that balances build time and query efficiency for irregular voxel distributions. These trees support efficient traversal for operations like ray intersection, making them valuable for accelerating access in large, sparse voxel sets. Sparse voxel octrees (SVOs) extend octrees for GPU-accelerated applications by storing only occupied nodes, achieving memory efficiency of O(klog⁡n)O(k \log n), where kk is the number of non-empty voxels and nn is the total grid resolution. This structure is widely adopted in real-time rendering, as it allows direct hardware traversal without full decompression, balancing sparsity with fast access for dynamic scenes. Other compression methods include transforms for lossy reduction in scientific volumetric data, which decompose voxels into components for selective retention of , yielding ratios from 8.5:1 to 28.2:1 depending on threshold settings. Additionally, hash-based sparse grids, as implemented in Unreal Engine's Nanite system, use hashing to index non-uniform geometry clusters, enabling virtualized micropolygon rendering with implicit sparsity for high-detail assets. These techniques involve trade-offs between compression ratios and processing overhead; for example, RLE can achieve up to 10:1 savings on uniform data but incurs decompression costs during , while hierarchical methods like SVOs offer logarithmic query times at the expense of build . Selection depends on data characteristics, with lossless options like RLE suiting exact reconstruction and lossy wavelets prioritizing visualization speed in resource-constrained environments.

Rendering and Visualization

Ray Casting and Tracing

Ray casting serves as a foundational technique for rendering voxel-based volumes by simulating light propagation through the 3D grid. In this method, rays are projected from the image plane (or viewer's eye point) into the voxel data structure, traversing the grid cell by cell or via direct volume access. Along each ray, discrete samples are taken at fixed or adaptive intervals, querying the voxel values to retrieve scalar densities or opacities, which are then classified and shaded to contribute color. These contributions are composited accumulatively from front to back, blending transparency and emission to form the final pixel intensity, as detailed in Marc Levoy's seminal 1988 algorithm for efficient volume rendering. This front-to-back approach allows for progressive integration of semi-transparent materials, enabling visualization of internal structures within the voxel grid without explicit surface extraction. Ray marching extends for more efficient traversal in voxel representations, particularly when using signed distance fields (SDFs) to define implicit surfaces or boundaries within the volume. Here, the ray advances in steps proportional to the SDF value at the current position, which estimates the distance to the nearest surface, preventing in while ensuring no gaps occur near . For volumetric densities stored in voxels, the step size is often adapted as Δt=min⁡(1density,[ϵ](/page/Epsilon))\Delta t = \min\left(\frac{1}{\text{density}}, [\epsilon](/page/Epsilon)\right), where ϵ\epsilon is a small margin, to maintain accuracy in high-density regions and accelerate traversal in sparse areas. This technique, applied to voxel grids via distance field representations, supports rendering of complex, implicit voxel geometries with reduced computational cost compared to uniform sampling. Ray tracing builds on these methods by incorporating advanced light interactions within voxel media, such as reflections and refractions at material interfaces or through participating media like fog. In voxel-based scenes, rays are recursively spawned at scattering events, simulating photon paths through the volume to capture effects like subsurface scattering or caustics in dense regions. Monte Carlo integration is commonly employed for global illumination, randomly sampling scattering directions and distances based on voxel densities to unbiasedly estimate radiance, which is particularly effective for heterogeneous volumetric media. This enables realistic depiction of light transport in applications like atmospheric effects, where voxels represent varying extinction coefficients. Performance optimizations are critical for practical use, including early ray termination once accumulated opacity reaches unity, which skips remaining samples along opaque paths and significantly reduces computation in dense voxel volumes. Hardware acceleration further enhances efficiency; for instance, NVIDIA's OptiX framework leverages GPU ray tracing cores to parallelize voxel traversal and intersection tests, achieving real-time rendering of complex voxel scenes at over 20 frames per second on hardware such as the NVIDIA Quadro FX 5800 (2008). Common artifacts in voxel ray casting and tracing include aliasing from insufficient sampling, manifesting as jagged edges or moiré patterns at boundaries, which can be mitigated through —casting multiple rays per and averaging results for smoother anti-aliased output. Monte Carlo-based tracing introduces from variance in random sampling, appearing as grainy textures in low-sample regimes; this is addressed using post-process denoising filters, such as edge-aware wavelets or neural networks, that reconstruct clean images while preserving details in the voxel-derived .

Rasterization Techniques

Rasterization techniques for voxels focus on projecting three-dimensional voxel data onto two-dimensional screens using hardware-accelerated methods, emphasizing efficiency for surface rendering over volumetric integration. These approaches convert discrete voxel grids into raster images by traversing or approximating surfaces, leveraging incremental computations to minimize processing overhead. Unlike ray-based methods, rasterization prioritizes speed through polygon approximation or direct filling, making it suitable for real-time applications where hardware pipelines can handle or quad primitives. One foundational rasterization method for voxels is incremental error rasterization, which extends to three dimensions for efficient voxel traversal during surface projection. This hardware-friendly technique uses to decide voxel inclusion along scanlines, avoiding floating-point operations and enabling fast implementation on early 3D graphics cards. Developed in the late 1980s, the 3D extension of Bresenham's algorithm determines the sequence of voxels intersected by a line or plane, facilitating scan-conversion of voxel-based into 2D pixels with minimal memory access. In the 1990s, patents incorporated similar incremental error mechanisms into graphics hardware for voxel-to-pixel mapping, supporting accelerated rendering of complex surfaces in systems like early 3D accelerators. A widely adopted rasterization strategy involves converting voxel volumes to polygonal meshes via extraction, particularly using the algorithm introduced by Lorensen and Cline in 1987. This method thresholds the of a voxel grid to identify surface boundaries, then interpolates vertices within each cubic cell based on vertex signs relative to the threshold, generating a triangulated suitable for standard GPU rasterization pipelines. The algorithm processes the volume cell-by-cell in a "marching" order, producing up to five triangles per cube to approximate smooth surfaces while preserving . This polygonization enables voxels to leverage conventional rendering hardware, reducing the complexity of direct voxel projection and achieving high-fidelity visuals for dense datasets. For optimizing distant or complex voxel structures, and techniques render voxels as oriented 2D quads with precomputed textures, serving as level-of-detail () approximations to maintain performance. face the viewer dynamically, while use depth or layered textures to simulate 3D from a single viewpoint, minimizing count for far-field rendering. In voxel contexts, volumetric extend this by stacking oriented slices or clouds of quads to represent semi-transparent voxel clusters, allowing real-time display of intricate details like foliage or clouds without full reconstruction. These methods reduce draw calls significantly for interactive rates in games and simulations. Modern rasterization of voxels increasingly utilizes GPU compute shaders in pipelines for advanced effects like real-time via voxel cone tracing (VCT). Introduced by Crassin et al. in , VCT voxelizes the scene into a 3D grid, then traces cones from surface points through the grid to approximate indirect , integrating occlusion and radiance in a rasterization pass post-voxelization. Compute shaders handle the construction and tracing, enabling dynamic updates at resolutions with 10-20 ms per frame on mid-range GPUs. This approach combines rasterization efficiency with volumetric accuracy, supporting hybrid rendering where primary surfaces are rasterized traditionally and secondary effects leverage voxel data. Recent advancements as of 2025 include dynamic voxel-based for handling static and dynamic objects with diffuse materials under changing lighting (Pharr et al., 2024) and GPU-driven voxel rendering frameworks like Aokana, which use sparse voxel directed acyclic graphs (SVDAGs), level-of-detail (), and streaming for efficient rendering of large voxel worlds in open-world games (Li et al., 2025). In the early 1990s, Incorporated (SGI) hardware pioneered rasterization for voxel medical visualization, using specialized workstations like the to implement shear-warp factorization for fast projection of volume data. This technique shears the voxel grid to align with the viewing axis, warps it to intermediate image space, and rasterizes via , achieving interactive rates for 256^3 datasets—up to five times faster than prior methods on SGI systems. Such implementations facilitated clinical adoption of voxel rendering for CT and MRI scans, emphasizing surface projection for diagnostic clarity.

Visual Examples

To illustrate the core principles of voxel rendering, consider a basic cubic voxel grid where each voxel is assigned a color based on its scalar value, such as or intensity. In a low-resolution example at 64³ voxels, the grid exhibits prominent artifacts, manifesting as jagged edges and blocky discontinuities when viewed from an angle; this is evident in renders produced using the Open3D library, which voxelizes simple geometric primitives like spheres or meshes into uniform grids. Conversely, a higher-resolution 256³ grid with smoothing techniques, such as Gaussian filtering applied during rendering, yields a more continuous appearance, mitigating while preserving the volumetric structure; this comparison highlights the trade-offs in resolution for visual fidelity, as demonstrated in PyVista's voxelization pipeline for surface meshes. Rendering time for the low-res version is typically under 0.1 seconds on modern GPUs, while the smoothed high-res render may take 1-2 seconds, using tools like Open3D for real-time visualization. In , voxel reconstructions from computed tomography (CT) scans provide a practical example of density-based coloring. A 512³ voxel dataset from a of a human kidney, for instance, colors voxels according to Hounsfield units—high-density structures in white (values >1000 HU) versus softer tissue in grayscale (200-500 HU)—revealing internal like and cortex with clear volumetric depth; this render, generated via in tools like VOXEL-MAN, emphasizes how voxel opacity mapping enhances organ differentiation without surface extraction. The reconstruction process from raw slices to rendered view takes approximately 5-10 seconds on standard hardware, showcasing the utility of voxels in non-destructive 3D visualization. Voxel-based game assets often embrace a deliberately blocky aesthetic, as seen in terrain renders mimicking Minecraft-style worlds. A 128³ section of procedural terrain, composed of stacked cubic voxels for soil, stone, and vegetation layers, displays the characteristic angular, low-poly look when rendered without smoothing, capturing earthy undulations and cave overhangs; this is exemplified in exports from MagicaVoxel, where individual blocks are textured for material variety like grass or ore veins. A smoothed variant, applying and subtle beveling, softens edges for a more organic feel while retaining voxel integrity, with rendering times around 0.5 seconds per frame in the tool's built-in path tracer, illustrating aesthetic flexibility in interactive environments. For advanced structures, sparse voxel octrees enable efficient rendering of complex scenes like cityscapes by storing only occupied regions. A 1024³ octree representation of an urban environment, voxelizing buildings and streets from 3D models, contrasts a dense full-grid fill with a sparse version that reduces memory via hierarchical pruning, both rendered to show global illumination effects; NVIDIA's Efficient Sparse Voxel Octrees framework demonstrates this on the "CITY" dataset, where sparse octrees at depth 13 achieve high performance of 126.6 Mrays/s (corresponding to interactive frame rates) on GTX 285 hardware, with sparsity reducing memory usage significantly compared to dense representations (e.g., from 1368 MB to 432 MB with contour optimization at depth 14). This comparison underscores compression benefits for large-scale visualizations, using GPU-accelerated ray tracing for realistic shadows and reflections.

Applications

Video Games and Graphics

Voxels have played a significant role in since the , particularly in rendering to overcome the limitations of polygon-based graphics at the time. In Outcast (1999), developed by , the game utilized a voxel engine for rendering expansive outdoor environments, allowing for smooth gradients and detailed landscapes without the geometric constraints of polygons. This approach enabled the creation of rolling hills and mountains through voxel interpolation, providing a sense of depth and scale that was innovative for software-rendered scenes. In modern block-based games, voxels form the foundation of vast, interactive worlds, with (2011) serving as a pioneering example. The game's universe is constructed on a cubic voxel grid, where procedural generation employs to create varied terrain heights and biomes seamlessly across infinite expanses. This method ensures coherent randomness, allowing players to explore and modify the environment in real-time while maintaining performance through chunk-based loading. Voxel-based physics have enabled advanced simulations of destructible environments, as seen in Teardown (2020) by Tuxedo Labs. The game features a fully interactive voxel world where players can demolish structures using vehicles, explosives, or tools, with simulating real-time destruction and debris interaction. This voxel approach supports , such as creating shortcuts through walls, while the underlying simulation handles fragmentation at a granular level for realistic collapse behaviors. Beyond world-building, voxels enhance graphics techniques like in game engines. Voxel Global Illumination (VXGI), developed by , approximates dynamic lighting by voxelizing scenes to trace indirect light propagation, integrated into engines such as Unreal Engine 4 for real-time effects without pre-baked lightmaps. This allows for responsive shadows and bounces in open-world games, improving visual fidelity in dynamic settings like those in Unity or Unreal projects. Despite these advances, voxel rendering in games faces challenges, particularly in large-scale worlds where empty space is essential to avoid processing vast unoccupied volumes. Techniques like octree-based partitioning and occlusion queries help mitigate this by skipping invisible voxels, enabling efficient rendering on modern hardware. Artistically, voxels often adopt a blocky aesthetic for stylized simplicity, but smoothing methods such as dual contouring can generate more organic surfaces by interpolating isosurfaces across voxel edges, balancing with visual appeal in titles pursuing varied styles.

Scientific and Medical Imaging

In medical imaging, computed tomography (CT) and magnetic resonance imaging (MRI) scans are commonly represented as voxel datasets, where each voxel encodes intensity values reflecting tissue density or signal strength. These volumetric representations enable three-dimensional analysis of anatomical structures, with CT voxels quantified using Hounsfield units (HU) to differentiate materials—air at -1000 HU, water at 0 HU, and soft tissues typically ranging from 20 to 80 HU. Segmentation techniques, such as thresholding, isolate regions of interest by selecting voxels within specific HU ranges; for instance, voxels between 0 and 100 HU can approximate for initial tumor boundary detection in CT scans. Voxel-wise analysis further supports tumor assessment, correlating CT and MRI data to monitor changes over time, such as increased in malignant lesions. Beyond , voxels facilitate precise delineation in other medical contexts, including voxel-based morphometry in MRI for quantifying brain tissue volume differences in neurodegenerative diseases. In scientific visualization, (CFD) simulations employ voxel grids to model fields and distributions in complex flows, such as around biological structures or dynamics in vascular networks. Each voxel stores vector components of alongside scalar properties like , allowing solvers to propagate motion across the grid while adhering to Navier-Stokes equations. This approach contrasts with mesh-based methods by enabling uniform discretization of irregular domains, as demonstrated in Eulerian-Lagrangian CFD models for porous media flows. Geophysical modeling leverages voxels to interpret seismic data, constructing subsurface structures from reflection amplitudes stored in volumetric grids. Voxelization techniques convert 2D seismic sections and borehole logs into 3D implicit models, interpolating properties like rock density or porosity to reveal faults and reservoirs. For example, regular voxel splitting with hierarchical interpolation enhances resolution in layered formations, aiding hydrocarbon exploration by visualizing stratigraphic continuity. Processing pipelines in these fields often integrate to visualize internal densities, projecting voxel data into photorealistic 3D views for organ assessment—such as rendering cardiac chambers from CT to evaluate ejection fractions. This direct technique samples opacity and color along rays through the voxel array, preserving spatial fidelity for applications like presurgical planning of organ models. Voxel meshes also support finite element analysis (FEA) for , converting segmented volumes into tetrahedral elements to simulate mechanical loads on or tissue; nonlinear voxel-based FEA, for instance, predicts fracture risk in metastatic femurs under compressive forces. algorithms refine voxel surfaces to mitigate stair-step artifacts, improving strain predictions in trabecular . The Digital Imaging and Communications in Medicine (DICOM) standard governs voxel data storage in medical imaging, encapsulating 3D arrays with metadata tags for spatial calibration—such as Pixel Spacing (0028,0030) for in-plane resolution and Slice Thickness (0018,0050) for inter-slice gaps, ensuring accurate voxel dimensions typically around 0.5–1 mm. Rescale Slope and Intercept attributes further normalize HU values across scanners. Advancements in the have introduced AI-assisted reconstruction, where neural networks synthesize 3D voxel volumes from limited 2D slices, enhancing resolution in sparse MRI datasets via generative models like convolutional autoencoders. These methods, such as adaptive equivariant CNNs, achieve superior segmentation accuracy on volumetric data by enforcing spatial consistency, reducing artifacts in reconstructed or organ scans.

Emerging Uses

Voxel-based models have gained prominence in additive manufacturing, particularly for creating complex lattice structures with variable that enhance mechanical properties while minimizing material use. These models discretize 3D designs into voxels, allowing precise control over internal architectures that traditional layer-based methods struggle with, such as graded lattices for lightweight components in applications. In (SLA) printing, voxel slicing techniques enable volumetric curing of photopolymers, supporting the fabrication of intricate, support-free structures by treating the build volume as a 3D grid rather than sequential 2D layers. This approach facilitates patient-specific implants and dynamic prototypes with embedded functionalities, achieving resolutions down to micrometers for biomedical uses. In virtual and , voxels support the creation of customizable avatars and immersive environments, enabling in social platforms. For instance, leverages voxel-based building tools to allow players to construct persistent worlds without specialized software, fostering collaborative experiences in the 2020s ecosystem. These voxel representations simplify deformation and interaction for avatars, integrating full-body tracking to enhance social presence in VR meetings and multiplayer scenarios. Such integrations extend to broader applications, where voxel data streams efficiently across devices for real-time editing and sharing of 3D spaces. Advancements in and increasingly utilize voxel data for 3D tasks, with 3D convolutional neural networks (3D CNNs) processing volumetric inputs to achieve high accuracy in . These networks apply filters across spatial dimensions to extract multi-scale features from voxel grids, outperforming 2D methods on tasks like shape classification in cluttered scenes. Generative models, such as VoxelGAN variants inspired by 3D-GAN architectures, synthesize realistic 3D volumes by learning probabilistic distributions from voxelized training data, enabling applications in for rare . These techniques have demonstrated up to 10% improvements in recognition precision on benchmark datasets like ModelNet, highlighting their role in scalable 3D . In simulation and , voxel occupancy grids provide a robust foundation for path planning, representing environments as probabilistic 3D volumes to detect free space and obstacles. Integrated into frameworks like the (ROS), these grids support real-time navigation for autonomous vehicles by converting voxel data into traversable maps, reducing computational overhead while maintaining safety margins. For instance, ROS-based systems use voxel layers to fuse sensor inputs for dynamic replanning around moving objects in unstructured terrains. In climate modeling, atmospheric voxel layers discretize global data into layered grids to simulate phenomena like and variations, aiding in the visualization and of patterns with high spatial fidelity. NASA's volume-rendered models exemplify this, using voxels to render multi-parameter atmospheric datasets for analysis of events such as wildfires. As of 2025, hybrid approaches combining voxels with neural radiance fields () have emerged for photorealistic rendering, blending explicit voxel structures with implicit neural representations to accelerate training and inference. These hybrids employ voxel splatting to propagate features in scene reconstruction, achieving real-time rendering speeds while preserving view-dependent effects in dynamic environments. Such integrations, as seen in 4D neural voxel splatting, extend capabilities to temporal data, enabling efficient synthesis of novel views for applications in and virtual production.

Tools and Software

Voxel Editors

Voxel editors are specialized software applications that enable users to create, modify, and manipulate voxel-based 3D models through intuitive graphical interfaces, primarily targeting artists, designers, and hobbyists in creation. These tools facilitate the construction of volumetric representations by allowing direct placement, removal, or alteration of individual voxels within a grid structure, often supporting real-time previews to aid . Popular examples include MagicaVoxel, released in 2014 as a free tool by Ephtracy, which provides real-time rendering capabilities and export options to formats like OBJ and for integration with other 3D pipelines. Another notable editor is Voxatron, developed by Lexaloffle Games in 2011, which is tailored for game development and emphasizes quick prototyping of voxel assets within a retro-style aesthetic. Core features of voxel editors typically encompass layer-based editing systems, where models can be organized into stacked layers for complex compositions, and sculpting tools that permit additive or subtractive operations on voxel clusters to shape organic or geometric forms. Palette systems allow for efficient color assignment, often with predefined or customizable color sets to maintain consistency in artistic workflows, while support enables keyframe-based modifications, such as transforming voxel positions or colors over time for simple motion sequences. These functionalities promote for non-programmers, enabling the creation of detailed models without requiring extensive coding knowledge. User interfaces in voxel editors are designed for precision and efficiency, featuring grid-based painting modes where users can "paint" voxels onto a 3D canvas using brushes of varying sizes and shapes. Symmetry mirroring tools assist in creating balanced designs by automatically duplicating edits across axes, and import capabilities often extend to converting data from 3D scans or polygonal meshes into voxel formats, bridging traditional modeling techniques with volumetric editing. Among open-source alternatives, Goxel stands out as a cross-platform editor that uses sparse matrices for efficient handling of large scenes without excessive memory use. VoxelShop, a Java-based tool, focuses on simplicity for beginners, offering basic editing for small-scale models with export to common 3D formats. Despite their strengths, voxel editors face limitations in managing very large datasets; for instance, resolutions exceeding 512³ voxels often demand hardware optimizations or to avoid performance bottlenecks and memory constraints.

Libraries and Frameworks

is an open-source C++ library developed by (initially in collaboration with Disney researchers) in 2012 for efficient storage and manipulation of sparse volumetric data in film , supporting structures like level sets and narrow-band signed distance fields. It employs a to handle high-resolution voxel grids with dynamic , enabling operations such as topology-preserving smoothing and at interactive speeds on large datasets. GVDB, released in 2017, extends this paradigm to GPU-accelerated processing via , providing a sparse voxel database for , , and ray-traced rendering of volumetric data on Pascal and later architectures. The library uses indexed memory pooling and to achieve efficient raytracing of sparse grids, supporting applications in real-time visualization and physics simulations. In game engine ecosystems, voxel integrations facilitate procedural content creation and runtime modifications. The Voxel Plugin for , a widely adopted third-party extension, enables graph-driven procedural world generation and runtime editing of voxel terrains, including support for Nanite integration in 5 for high-fidelity rendering. Version 2.0 was released in early 2025, introducing runtime Nanite support and advanced material painting capabilities. For Unity, plugins like Cubiquity provide voxel-based terrain editing with capabilities, allowing caves, overhangs, and deformable landscapes through C++-backed PolyVox integration. Several open-source voxel engines for Unity exist on GitHub, typically in C#, but none match year-specific criteria for 2025 or 2026 in available sources. These tools often export voxel data in formats compatible with standalone editors for further refinement. Scientific computing libraries offer robust voxel processing pipelines. The Insight Toolkit (ITK), an open-source framework for medical image analysis, includes extensive filters for 3D voxel data, such as recursive Gaussian smoothing implemented as (IIR) convolutions to reduce noise while preserving edges in volumetric scans. The Visualization Toolkit () complements this with rendering pipelines for voxel volumes, supporting techniques like and extraction to visualize medical and scientific datasets in 3D. At the programming level, voxels are commonly represented using multidimensional . In Python, NumPy's ndarray class efficiently handles 3D voxel grids through array operations like slicing and broadcasting, forming the basis for custom voxel manipulations in scientific workflows. For C++, Boost.Geometry provides spatial indexing via R-trees for efficient queries on voxel datasets, such as nearest-neighbor searches or range intersections in 3D space. Recent advancements include browser-based libraries leveraging WebGL for voxel rendering. Voxel.js, an evolving JavaScript framework with updates into the 2020s, enables procedural voxel worlds in web applications using Three.js for graphics, supporting chunked terrain generation and multiplayer interactions directly in the browser.

Extensions

Sparse Voxels

Sparse voxels represent a memory-efficient extension to traditional voxel grids by storing data only for occupied or non-empty regions, thereby eliminating the need to allocate resources for vast expanses of empty space inherent in most 3D scenes. In typical 3D environments, such as those encountered in computer graphics or virtual simulations, more than 90% of the voxel space is often empty, resulting in substantial waste when using dense grids that uniformly cover the entire volume. This approach addresses the inefficiency of dense representations, particularly in sparse scenarios like architectural models or outdoor terrains where geometry occupies only a fraction of the bounding volume. A key structure for implementing sparse voxels is the (SVO), a hierarchical that extends octrees by selectively subdividing space based on occupancy. In an SVO, each internal node corresponds to a cubic volume and contains pointers to up to eight child nodes, which may be further sub-octrees or leaf voxels containing actual data; empty regions are represented implicitly by the absence of nodes, allowing for compact storage. Traversal methods, such as , leverage this hierarchy by skipping entire empty branches, which accelerates queries like intersection testing or visibility determination. For practical implementation, SVOs employ techniques like node pooling on GPUs to reuse memory allocations dynamically, often using compact 32-bit child pointers to index into a pool of nodes rather than full addresses. Construction typically involves initial voxelization of input data, such as point clouds or triangle meshes, followed by bottom-up aggregation to build the tree hierarchy; this process can be accelerated using GPU rasterization to fill leaf nodes efficiently before merging. In real-time applications, SVOs enable advanced rendering techniques, exemplified by CryEngine's Sparse Voxel Octree (SVOGI) system, which was integrated starting in 2015 to support dynamic in video games through voxel-based ray tracing of sparse scenes. The benefits of sparse voxels include dramatic savings—for instance, achieving roughly 1/10th the storage of a dense grid in scenes with high emptiness—making them suitable for large-scale or resource-constrained environments. However, the non-uniform structure introduces traversal overhead, as algorithms must navigate pointers and handle branching logic, potentially increasing compared to regular grids.

Adaptive and Hierarchical Voxels

Hierarchical voxels extend traditional uniform grids by organizing data into multi-resolution structures, such as octrees or mipmapped pyramids, to enable level-of-detail (LOD) rendering based on viewer distance or importance. In these approaches, coarser levels approximate distant or less critical regions to reduce computational load, while finer resolutions capture details in closer areas, similar to 2D texture mipmapping but applied to 3D volumes. For instance, octree-based hierarchies dynamically select resolution levels from multi-scale primitives, achieving consistent real-time rendering in complex scenes by balancing quality and efficiency. Adaptive voxels introduce non-uniform cell shapes, such as sheared or anisotropic grids, to better align with underlying phenomena like fluid flow, improving accuracy without excessive grid refinement. In fluid , these grids use tilted or staggered structures to conform to flow directions, enabling efficient handling of large-scale incompressible flows on adaptive hexahedral layouts that support over a billion voxels on multiprocessor systems. This adaptability minimizes artifacts in anisotropic domains, such as biological tissues or dynamic liquids, by prioritizing resolution where gradients are steep. Dual contouring is an algorithm for extracting smooth surfaces from hierarchical , placing vertices at optimal positions to preserve sharp features and avoid the cracking issues of . Introduced in , it operates on signed fields with Hermite data—intersection points and normals on grid edges—to generate manifold meshes that adapt to multi-resolution octrees, ensuring watertight even across level transitions. The method excels in applications requiring precise , such as modeling, by minimizing surface approximation errors in adaptive hierarchies. Nanovoxels achieve sub-voxel precision through offset or dual-grid techniques, allowing fractional positioning within cells to enhance rendering quality in voxel engines. These offsets enable by pre-filtering subpixel data in sparse representations, reducing artifacts on silhouettes without fully subdividing the grid, as demonstrated in octree-based massive model visualization. In practice, this supports smoother transitions in dynamic scenes, integrating with hierarchical structures for efficient sub-geometry handling. Recent research explores integrating adaptive hierarchical voxels with for efficient , using octree-based sampling to refine resolution in sparse, AI-generated scenes. Dynamic PlenOctrees, for example, enable adaptive refinement in explicit NeRF variants, combining voxel hierarchies with neural densities to accelerate training and inference for real-time novel view synthesis. This hybrid approach, often merged briefly with sparse voxels, holds potential for scalable in the 2020s.

References

  1. https://www.merriam-webster.com/dictionary/voxel
  2. https://dsplab.feri.um.si/glossary/voxel/
  3. https://www.evl.uic.edu/vchand2/thesis/papers/volume-graphics.pdf
  4. https://pubmed.ncbi.nlm.nih.gov/3286114/
  5. https://www.sciencedirect.com/science/article/abs/pii/S0895611199000154
  6. https://www.engineering.com/what-is-a-voxel-in-3d-printing/
  7. https://ieeexplore.ieee.org/document/9028111
  8. https://www.chai3d.org/download/doc/html/chapter12-volume.html
  9. https://ieeexplore.ieee.org/document/5159347/
  10. https://groups.csail.mit.edu/graphics/classes/6.838/S98/meetings/m7/voxels.html
  11. https://dl.acm.org/doi/pdf/10.5555/949845.949864
  12. https://arxiv.org/html/2410.06475v1
  13. https://dl.acm.org/doi/full/10.1145/3622934
  14. https://www-users.cse.umn.edu/~interran/papers/chapter94.pdf
  15. https://www.oed.com/dictionary/voxel_n
  16. https://computerhistory.org/blog/the-remarkable-ivan-sutherland/
  17. https://www.ncbi.nlm.nih.gov/books/NBK574548/
  18. https://graphics.stanford.edu/papers/volume-cga88/
  19. https://dl.acm.org/doi/10.1145/125137.125155
  20. https://futhark-lang.org/student-projects/futspace-bsc-thesis.pdf
  21. https://graphics.stanford.edu/projects/volume/
  22. https://link.springer.com/article/10.1134/S0361768807060047
  23. https://www.sciencedirect.com/science/article/pii/S1569843223001383
  24. https://pmc.ncbi.nlm.nih.gov/articles/PMC3948928/
  25. http://www.paulbourke.net/dataformats/vox/
  26. https://www.itksnap.org/pmwiki/pmwiki.php?n=Documentation.TutorialRawInput
  27. https://www.research.autodesk.com/app/uploads/2023/06/Algorithms-for-VASA.pdf
  28. https://dl.acm.org/doi/10.1145/1730804.1730814
  29. https://www.cs.purdue.edu/cgvlab/www/resources/papers/Benes-2006-A_Compression_Scheme_for_Volumetric_Animation_of_Running_Water.pdf
  30. https://afra.dev/publications/Afra2012VoxLOD.pdf
  31. https://graphicsinterface.org/wp-content/uploads/gi1998-14.pdf
  32. https://www.unrealengine.com/en-US/blog/understanding-nanite---unreal-engine-5-s-new-virtualized-geometry-system
  33. https://dl.acm.org/doi/10.1145/78964.78965
  34. https://iquilezles.org/articles/raymarchingdf/
  35. https://cs.dartmouth.edu/~wjarosz/publications/novak18monte.pdf
  36. https://diglib.eg.org/bitstreams/8725f267-0ad8-4bc0-bf83-c5a5713c128b/download
  37. https://www.semanticscholar.org/paper/3D-scan-conversion-algorithms-for-voxel-based-Kaufman-Shimony/9b5e1bd18f1c8864cb5c0d395b3bbdeb4e828f2a
  38. https://dl.acm.org/doi/10.1145/37402.37422
  39. https://dl.acm.org/doi/10.1145/1201775.882326
  40. https://onlinelibrary.wiley.com/doi/10.1111/cgf.15262
  41. https://arxiv.org/abs/2505.02017
  42. https://graphics.stanford.edu/papers/shear/lacroute-shearwarp-sig94.pdf
  43. https://www.open3d.org/docs/latest/tutorial/Advanced/voxelization.html
  44. https://docs.pyvista.org/examples/01-filter/voxelize.html
  45. https://www.virtual-body.org/gallery/
  46. https://ephtracy.github.io/
  47. https://research.nvidia.com/sites/default/files/pubs/2010-02_Efficient-Sparse-Voxel/laine2010tr1_paper.pdf
  48. https://francksauer.com/index.php/games?view=article&id=47:outcast-pc&catid=15:published-games
  49. https://timigi.com/Stuff/Archive/outcast/development.html
  50. https://gamedev.stackexchange.com/questions/148826/minecraft-style-world-generation
  51. https://store.steampowered.com/app/1167630/Teardown/
  52. https://teardowngame.com/
  53. https://www.nvidia.com/en-us/geforce/technologies/vxgi/
  54. https://developer.download.nvidia.com/assets/events/GDC15/GEFORCE/VXGI_Dynamic_Global_Illumination_GDC15.pdf
  55. https://www.gamedeveloper.com/art/voxelart-styles-in-video-games
  56. https://nickmcd.me/2021/04/04/high-performance-voxel-engine/
  57. https://dexyfex.com/2016/05/16/voxels-and-dual-contouring/
  58. https://www.researchgate.net/figure/D-medical-image-data-From-pixels-to-voxels_fig1_237802930
  59. https://ajronline.org/doi/10.2214/AJR.12.10037
  60. https://www.sciencedirect.com/science/article/pii/S1120179721002672
  61. https://pmc.ncbi.nlm.nih.gov/articles/PMC6037934/
  62. https://datature.com/blog/a-comprehensive-guide-to-3d-models-for-medical-image-segmentation
  63. https://www.research.autodesk.com/app/uploads/2023/03/fast-fluid-dynamics-on.pdf_recZxLHseys3jxzKm.pdf
  64. https://cad-journal.net/files/vol_19/CAD_19%286%29_2022_1236-1254.pdf
  65. https://onlinelibrary.wiley.com/doi/full/10.1002/ceat.202000318
  66. https://www.exprodat.com/blog/turning-seismic-data-into-a-voxel-layer-in-arcgis-pro/
  67. https://www.researchgate.net/publication/236164124_Considerations_on_voxelization_techniques_for_3D_geological_and_geophysical_modeling_using_borehole_data_and_seismic_section_interpretation_-_examples_from_Little_Hungarian_Plain_Pannonian_Basin
  68. https://www.nature.com/articles/s41598-022-17231-x
  69. https://arxiv.org/pdf/1802.07710
  70. https://www.jove.com/t/63214/voxel-printing-anatomy-design-fabrication-realistic-presurgical
  71. https://pmc.ncbi.nlm.nih.gov/articles/PMC7163060/
  72. https://people.inf.ethz.ch/arbenz/lssc07.pdf
  73. https://www.sciencedirect.com/science/article/pii/S1319157820305802
  74. https://www.mathworks.com/help/medical-imaging/ref/medicalvolume.html
  75. https://arxiv.org/pdf/2402.16825
  76. https://arxiv.org/html/2508.07237v1
  77. https://www.tandfonline.com/doi/full/10.1080/17452759.2025.2526032
  78. https://www.cnet.com/tech/gaming/rec-rooms-big-plans-for-the-metaverse-so-much-more-than-a-game/
  79. https://www.uploadvr.com/rec-room-full-body-avatars-beta-everyone/
  80. https://arxiv.org/abs/1805.12254
  81. https://ar5iv.labs.arxiv.org/html/2203.05550
  82. https://journals.sagepub.com/doi/10.1177/1729881420910530
  83. https://svs.gsfc.nasa.gov/4180
  84. https://goxel.xyz/
  85. https://www.openvdb.org/documentation/
  86. https://www.museth.org/Ken/Publications_files/Museth_TOG13.pdf
  87. https://developer.nvidia.com/gvdb
  88. https://github.com/NVIDIA/gvdb-voxels
  89. https://diglib.eg.org/bitstream/handle/10.2312/hpg20161197/109-117.pdf
  90. https://voxelplugin.com/
  91. https://80.lv/articles/voxel-plugin-2-for-unreal-engine-5-announced
  92. https://docs.voxelplugin.com/1.2/
  93. https://discussions.unity.com/t/cubiquity-a-fast-and-powerful-voxel-plugin-for-unity3d/506277
  94. https://docs.itk.org/projects/doxygen/en/stable/classitk_1_1SmoothingRecursiveGaussianImageFilter.html
  95. https://vtk.org/
  96. https://docs.vtk.org/
  97. https://numpy.org/doc/stable/reference/arrays.ndarray.html
  98. https://github.com/joshmarinacci/voxeljs-next
  99. https://voxel.github.io/voxeljs-site/
  100. https://www.icare3d.org/research/publications/CG12/GTC2012_Voxelization_public.pdf
  101. https://www.cryengine.com/news/view/check-out-miscreated-the-first-game-to-feature-svogi
  102. https://johanna-b.github.io/files/documents/STAR_CGF_GPULargeScaleVolVis.pdf
  103. https://www.digipen.edu/sites/default/files/public/docs/theses/alexander-n-pecoraro-digipen-master-of-science-in-computer-science-thesis-gigavoxel-paged-terrain-generation-and-rendering.pdf
  104. https://cs.nyu.edu/~sw4429/data/paper/sa20-fluid.pdf
  105. https://www.researchgate.net/publication/264937607_Large-Scale_Liquid_Simulation_on_Adaptive_Hexahedral_Grids
  106. https://pmc.ncbi.nlm.nih.gov/articles/PMC2837787/
  107. https://www.cs.wustl.edu/~taoju/research/dualContour.pdf
  108. https://inria.hal.science/hal-00704461/file/HN12.pdf
  109. https://scispace.com/pdf/an-anti-aliasing-technique-for-voxel-based-massive-model-274v0ggbj7.pdf
  110. https://openaccess.thecvf.com/content/ICCV2023/papers/Bai_Dynamic_PlenOctree_for_Adaptive_Sampling_Refinement_in_Explicit_NeRF_ICCV_2023_paper.pdf
  111. https://www.ecva.net/papers/eccv_2022/papers_ECCV/papers/136770258.pdf
Add your contribution
Related Hubs
User Avatar
No comments yet.