How ivandrodri/gpu-voxelizer works
Based on our analysis of the file tree and README content, this project is a GPU-accelerated voxelization tool built mostly in CUDA/C++ for processing 3D meshes (using surface voxelization) with an accompanying Python-based Streamlit GUI for visualization and interactions. The project also supports two connector options: a local connector (where both engine and GUI run on the same machine) and a REST API connector (with a simple server implemented in Python) that can be used for remote execution.
• GPU Voxelization Engine:
• Represents the core processing engine written in CUDA/C++.
• Subdivide this into logical modules such as Mesh Processing, Voxelization (surface and the planned bulk voxelization), Mathematical Utilities, and Logging. These modules are present in the “mesh_voxelization” folder.
• Associate the build system (CMake, Dockerfiles) with these components.
• GUI/Visualization Layer:
• Streamlit-based application (voxelizer_gui) that provides the user-facing interface.
• Underline that it follows a Controller-Model-View (CMV) pattern (with modules in “voxelizer_gui/src/gui_components”) to promote modularity and separation of concerns.
• Connectors/Integration Layer:
• “Connector” abstraction from voxelizer_gui/src/connector.
• Two possible realization paths:
• Local Connector – for invoking the GPU engine directly within the same process/machine.
• REST API Connector – where the GUI communicates with a separate REST API server.
• REST API Server (Endpoints):
• “end_points_voxelizer” component that provides a server implemented in Python. This is intended for remote interactions with the voxelization engine.
• Supporting Utilities:
• “shared_utils” for metadata and utility functions.
• External libraries (OpenMeshMirror, glog, cxxopts, googletest) from the “external” directory.
• Dependencies on the CUDA Toolkit, proper NVIDIA drivers, and compiler toolchains.
• Optionally, note that “data” (like STL files and images) is used for input/output and visualization samples.
Relationships and Data Flow
• From the Connector to the GPU Voxelization Engine. Depending on the chosen connector (Local vs. REST), indicate either a direct call or an HTTP/REST request.
• From the REST Connector to the REST API Server – if this communication mode is selected.
Architectural Patterns and Design Principles
• That the GUI follows a Controller/Model/View (CMV) design pattern, ensuring separation between user-interface logic and business logic.
• Modularity – the distinct separation between the GPU-based processing and the user interface via abstract connectors.
• That the system is designed to be extensible: for example, switching between local and remote (REST API-based) operations is achieved via a connector interface.
Technologies and Frameworks
• CUDA and C++ for low-level GPU computations (as seen in the “mesh_voxelization” and “main” directories).
• Python and Streamlit for the GUI visualization (voxelizer_gui).
• CMake for building the C++ code.
• Docker for environment consistency and containerized execution.
• Pre-commit hooks and testing frameworks (googletest, etc.) are used for code quality and testing.