Core 3D Data Paradigms
Introduction​
Now that we've established what 3D space is from first principles, we can turn to the question of how data actually occupies that space. In 3D work, geometry is not a single, universal thing; it is expressed through a small number of fundamentally different representation paradigms. The core four are polygonal surfaces, NURBS surfaces, volumetric/implicit fields, and solid modeling, with point clouds forming a fifth, auxiliary category used primarily in reconstruction and measurement.
Each paradigm encodes geometry using its own mathematical logic: polygons through discrete vertices and faces, NURBS through continuous analytic surfaces, solids through boundary-defined volumes, and volumetrics through fields of density or distance. Point clouds differ again, describing samples of space without defining surfaces at all.
Because each paradigm conceptualizes geometry differently, moving between them is never seamless; it always requires conversion, interpretation, or approximation. Understanding these paradigms and their strengths, limitations, and conversion costs is essential for choosing the right workflows in Blender and for managing evidence in visual investigation.
Key Insights
- The five core geometry paradigms
- Polygonal vs NURBS comparison
- When to use each approach
Core Concepts
- Volumetrics and point clouds
- Subdivision surfaces (SubD)
- Conversion between paradigms
Why It Matters
Understanding paradigms prevents treating incompatible data types as interchangeable, a common source of error in investigation.
Blender is fundamentally a polygonal modeling tool. This is its core strength and the paradigm around which its tools, workflows, and modifiers are designed. While Blender can interface with other paradigms, importing point clouds, rendering volumetric data, or offering minimal NURBS support, these are secondary capabilities rather than native modeling systems.
In visual investigation, however, you can encounter multiple paradigms in the same project:
-
point clouds from LiDAR, photogrammetry, or SfM workflows,
-
volumetric datasets from scientific or forensic sources,
-
polygonal geometry created manually or derived from reconstruction.
Each paradigm behaves according to its own mathematical rules. Confusing them, or attempting to treat them as interchangeable, is one of the fastest ways to lose precision, waste time, or produce geometry that cannot be verified or exported. Knowing what type of data you are looking at is as important as knowing what you intend to do with it.
In the following sections, we will examine volumetrics, point clouds, and NURBS first, the paradigms you are most likely to encounter but least likely to edit directly in Blender. We will then conclude with polygonal modeling, the paradigm at the heart of Blender’s design and the one in which you will conduct the majority of your investigative reconstruction work.
Volumetrics​
Volumetric data populates 3D space by filling it, not by outlining it. Instead of defining surfaces, a volumetric representation divides space into countless tiny cells (voxels). Each voxel stores a value, such as density, color, temperature, or distance to the nearest surface. When combined, these values describe a field that occupies the entire region of interest.
Volumetrics excel at capturing shapes and phenomena that surface-based representations struggle with: smoke, fog, fluids, fire, atmospheric effects, or highly irregular organic forms. In investigative contexts, you may encounter volumetric data from medical imaging (CT or MRI scans), scientific simulations (fluid dynamics, blast analysis), or fire and smoke reconstruction in arson investigations.
Blender supports volumetric datasets through the OpenVDB format, an industry-standard sparse volume representation developed for visual effects. VDB files can store density fields, level sets (implicit surfaces defined by distance), or vector fields (velocity, direction). Blender's volume object and shader system can import, display, and render these datasets, making them useful for visualizing complex phenomena or extracting cross-sections for analysis.
The tradeoff is resolution: higher fidelity demands finer voxel grids, which rapidly increases memory and computation requirements. A detailed volumetric scan can easily exceed multiple gigabytes. Blender's editing capabilities for volumetrics are also limited—you can adjust display settings, apply transformations, and render the data, but sculpting or modifying voxel fields directly requires specialized software like Houdini or EmberGen.
In Blender-based visual investigation, volumetrics serve primarily as data sources or intermediate representations: you import them for context, extract isosurfaces (converting density thresholds into polygonal meshes), or use them as visual reference while modeling polygonal geometry around them. Treat volumetrics as evidentiary data to be interpreted rather than directly edited geometry.
Point Clouds​
A point cloud is a set of discrete points floating in 3D space. Each point stores spatial coordinates (x, y, z) and sometimes extra information such as color, reflectance, or intensity. Importantly, that is all it contains: no surfaces, no edges, no faces, and no notion of how one point relates to another.
Point clouds typically originate from real-world measurement systems. LiDAR records the return time of laser pulses, photogrammetry reconstructs points by triangulating image features, and depth sensors emit structured light or infrared patterns to infer distance. The strength of point clouds is their directness: they represent raw observational data with minimal interpretation. For visual investigation, this makes them an important and increasingly common source of spatial evidence.
As scanning technology becomes more accessible—handheld LiDAR scanners, drone-mounted systems, and smartphone depth sensors—point clouds are appearing in more investigative contexts: crime scene documentation, accident reconstruction, building surveys, and site analysis. They offer millimeter-level precision across large areas, capturing spatial relationships that would be impractical to measure manually.
However, points alone do not define shape. A point cloud has no topology, no interior or exterior, and no continuous surface. Converting a cloud into a mesh requires estimation; algorithms infer where a surface ought to be based on point distribution. Real scanner data also contains noise, missing patches, outliers, and uneven density, which complicate reconstruction. Registration—aligning multiple scans into a single coordinate system—adds another layer of complexity.
Blender can display point clouds efficiently using the Geometry Nodes system, but its ability to edit them directly is limited. In most workflows, you will use point clouds for visual inspection or as spatial reference, and then perform one of two actions:
- Convert the cloud to a mesh for modeling or measurement using external tools (CloudCompare, Meshlab) or Blender add-ons, then refine the result in Blender.
- Model on top of it using polygonal tools while treating the cloud as a three-dimensional guide, similar to rotoscoping over reference imagery.
Point clouds are therefore best understood as measurement data—a high-fidelity spatial record that serves as the foundation for subsequent modeling, analysis, or verification. As these datasets become standard in investigative workflows, knowing how to interpret, align, and extract geometry from them will be an essential skill.
Solid Modeling​
Solid modeling represents objects as complete, closed volumes with defined interiors and exteriors. Unlike surface-based approaches, a solid model always "knows" what is inside and what is outside. This is achieved through boundary representation (B-rep) or constructive solid geometry (CSG), where simple primitives (cubes, cylinders, spheres) are combined using boolean operations: union, difference, and intersection.
Solid modeling dominates mechanical engineering and architecture because it guarantees manifold geometry—watertight objects with no holes, flipped normals, or ambiguous boundaries. When you subtract one solid from another, the software maintains volume integrity. This makes solids ideal for manufacturing specifications, structural analysis, and any workflow requiring physical properties like mass or volume calculations.
In visual investigation, you encounter solid models when working with building information modeling (BIM) data, product designs, or any CAD file exported from engineering environments. These files often arrive as .step, .iges, or .sat formats. Blender can import them, but the underlying solid logic is lost in translation; you receive a polygonal mesh approximation. Blender's boolean modifier can simulate CSG operations on meshes, but unlike true solid modelers, it does not guarantee topologically valid results in all cases.
For investigative purposes, solid models are valuable as reference geometry or when precise volumetric data matters—calculating the displacement of a component, verifying dimensional compliance, or establishing spatial occupancy. Once imported into Blender, they become polygonal meshes and follow Blender's standard modeling rules.
NURBS​
NURBS (Non-Uniform Rational B-Splines) define smooth shapes using control points and mathematical equations. You can think of a NURBS surface as a flexible sheet held in place by pins: move a pin, and the entire sheet deforms smoothly and continuously. This makes NURBS exceptionally good at representing curvature with mathematical precision.
NURBS dominate CAD and industrial design environments such as Rhino, SolidWorks, and CATIA. In these systems, NURBS are integrated into a parametric modeling workflow: dimensions, constraints, and relationships govern how parts update. Change one measurement, and the entire object recalculates itself. This rule-driven approach is invaluable for engineering and iterative design.
Where NURBS excel is smooth, continuous, precision surfaces: aircraft skins, car exteriors, product housings, and architectural components. They are less well-suited to sharp details, intricate branching topology, or irregular organic forms. The underlying mathematics can also make operations brittle; trimming, joining, or blending surfaces can produce unexpected artifacts or failures.
In visual investigation, you may encounter NURBS when working with engineering, architectural, or manufacturing files. Blender can import and display NURBS curves and surfaces, but its NURBS toolset is minimal, and its overall workflow is not designed around surface-patch modeling. For almost any practical task inside Blender, NURBS are converted to polygonal meshes, where Blender’s modeling tools are strongest and most predictable.
Although NURBS is central to engineering and product-design pipelines, it is a misconception that Blender cannot be used for precision work. Blender’s polygonal tools, combined with accurate reference scaling and snapping, allow for the creation of highly accurate models suitable for 3D printing and other tolerance-sensitive workflows.
Polygonal Modeling​
Polygonal modeling is the foundation of Blender's toolset and the paradigm you will use for the majority of your work. A polygonal mesh is composed of three interconnected elements: vertices (points in space), edges (lines between vertices), and faces (flat surfaces enclosed by edges). These discrete components allow direct, intuitive manipulation—move a vertex, and connected edges and faces update accordingly.
Because we covered points, lines, and planes in the previous chapter, you already understand the mathematical primitives that polygons build upon. A face is simply a filled plane defined by vertices; an edge is a line segment connecting two points. What makes polygonal modeling powerful is how these simple elements combine to approximate any shape through tessellation—breaking complex forms into many small, flat facets.
Polygonal meshes excel at flexibility and editability. You can select individual components, apply localized transformations, and build geometry incrementally. They also offer universal compatibility; nearly every 3D software reads and writes polygon-based formats like .obj, .fbx, and .ply. The tradeoff is that smooth curves require dense geometry—more faces mean more accurate curvature, but also heavier files and slower performance.
In the following chapters, we will examine the anatomy of polygonal meshes in detail: how vertices, edges, and faces interact to form topology, what polycount means for performance and precision, and how to build clean, investigatively sound geometry. For now, understand that when you model in Blender, you are working directly with these discrete elements, and that directness is both Blender's greatest strength and the reason it differs fundamentally from NURBS-based CAD systems.
Polygonal vs. NURBS: A Modeling Decision​
When building 3D geometry from scratch, the practical choice narrows to two paradigms: NURBS and polygonal modeling. Let's have a look at how they compare in their essence.
If we play around with the element above and switch between modeling modes in the right N-Panel, the key tradeoff emerges. NURBS surfaces achieve smooth curves with significantly fewer control points than polygonal modeling requires. Polygons approximate smoothness through subdivision. This is a recursive technique dividing faces to create finer geometry. However, this increases face count exponentially, making the mesh computationally heavier. This explains why NURBS excels at smooth, precision-defined surfaces, while polygonal subdivision offers you direct control over mesh density and structure.
Subdivision Surfaces: Bridging Polygonal and Smooth Modeling​
Subdivision Surface modeling (SubD) offers a middle path between polygonal directness and NURBS-like smoothness. The concept is straightforward: you model a simple, low-resolution mesh (the "control cage"), and Blender calculates a smooth, subdivided version for display and rendering. Move a vertex on the cage, and the smooth result updates in real time.
SubD works through recursive subdivision algorithms—typically Catmull-Clark—that split each face into smaller faces while smoothing the result according to surrounding geometry. This allows you to work with manageable polygon counts while achieving organic, curved surfaces. The technique is common in character modeling, product visualization, and any workflow requiring smooth forms without manual high-resolution sculpting.
However, SubD requires careful topology. To produce predictable results, your base mesh should consist primarily of four-sided faces (quads) with good edge flow. Triangles and n-gons (faces with more than four sides) can create unexpected artifacts or pinching. This constraint makes SubD a discipline of its own, which we will explore in a dedicated chapter.
In visual investigation, SubD is less common than direct polygonal modeling—most forensic reconstruction prioritizes measurable accuracy over organic smoothness. But understanding SubD is valuable for two reasons: it clarifies the relationship between polygonal and NURBS paradigms, and it provides a tool for situations where you need smooth reference geometry without excessive polycount. Consider it an available technique rather than a default workflow.
Hybrid Paradigm Workflows​
In practice, investigative 3D work rarely relies on a single paradigm. Real-world projects combine measurement data, reference models, and newly created geometry, each originating from different sources and requiring different handling. Understanding how paradigms connect in typical workflows prevents confusion and preserves data integrity.
A common reconstruction pipeline follows this sequence:
Point Cloud → Polygonal Mesh → Subdivision Surface
- Begin with a LiDAR or photogrammetry point cloud capturing the scene or object.
- Convert the cloud to a polygonal mesh using reconstruction algorithms (Poisson surface reconstruction, ball-pivoting, or alpha shapes).
- Clean and refine the mesh in Blender: remove artifacts, fill holes, simplify dense regions.
- If smoothness is required, apply subdivision surface modeling to the refined base mesh.
Another frequent scenario involves integrating CAD reference data:
NURBS/Solid Model → Polygonal Approximation → Investigation Model
- Import architectural plans or product designs (often as .step or .iges files).
- Blender converts these to polygonal meshes automatically on import.
- Use the imported geometry as dimensional reference while building an investigative model with accurate measurements and simplified topology suitable for analysis.
Volumetric datasets follow a similar pattern of extraction and conversion:
Volumetric Field → Isosurface Extraction → Polygonal Mesh
- Import VDB or medical imaging data as volumetric objects.
- Extract polygonal surfaces at specific density thresholds (equivalent to contouring).
- Refine the resulting mesh for measurement or further modeling.
The key insight is that each paradigm serves a specific role: point clouds and volumetrics provide spatial evidence, NURBS and solid models supply engineering-grade reference, and polygonal meshes become your working geometry in Blender. At some points conversion is inevitable, but by understanding what each paradigm offers and what is lost in translation, you can design workflows that preserve investigative integrity while leveraging Blender's strengths.
In the chapters ahead, we will focus on polygonal modeling, the paradigm in which you will spend most of your time. But remember that the data feeding your models may originate elsewhere, and knowing how to bridge those paradigms is as important as mastering any single one.
Conclusion​
Blender is built for the polygonal paradigm, and that will be our focus. But this doesn't mean we cannot include data from other paradigms; we can import, visualize, and convert between them as needed.
Summary​
Understanding the different geometry paradigms helps you make informed decisions about data handling and workflow choices.
Key Takeaways:
- Five core paradigms exist: Polygonal, NURBS, Volumetric, Solid, and Point Clouds
- Blender is optimized for polygonal modeling, its primary strength
- Point clouds are raw measurement data, not editable geometry
- NURBS excel at smooth, precision surfaces but require conversion for Blender work
- Subdivision surfaces bridge the gap between polygonal and smooth modeling
- Converting between paradigms always involves interpretation or approximation