How alicevision/meshroom works
Main components
• User Interface (UI):
• Located under meshroom/ui and its subdirectories (qml, components, graph editor, Viewer, etc.). This is where the end-user interacts with the software.
• Core Processing Engine:
• Found under meshroom/core (including modules for graph management, task management, node handling, and computation). It orchestrates the 3D reconstruction pipeline.
• Pipeline and Nodes Framework:
• Trees in meshroom/nodes and the related descriptor files under meshroom/core/desc. This represents the modular node-based processing pipeline where each node performs a specific photogrammetry or processing task.
• External Integration:
• Integration with the AliceVision library (as required in the README and launch instructions), which provides the photogrammetry computer vision functionality.
• Command-Line Tools:
• Utilities and batch executables in the bin/ directory (such as meshroom_batch, meshroom_compute, etc.) for non-interactive 3D reconstruction and advanced automation.
• Submitters and Distributed Processing:
• Modules under meshroom/submitters are used for task submission (e.g., to a simple farm or cluster environment).
• Supporting Infrastructure:
• Build and dependency files (e.g., CMakeLists.txt, setup.py, docker/) along with configuration files for CI, documentation (docs/), and testing (tests/) indicate supporting components for development, deployment, and quality assurance.
Relationships and Interactions
• “Pipeline/Nodes Framework” as a modular layer plugged into the Core Engine. Here, each node (described by meshroom/core/desc and actual code in meshroom/nodes) is a distinct component that can be extended by custom nodes.
• Incorporate a “Command-Line Interface” block that interacts directly with the core engine (through scripts in bin/) to execute batch jobs or debug tasks.
• Optionally, include the “Submitters Module” which mediates between the basic node execution and distributed computing resources, especially for scaling compute-intensive tasks.
Architectural Patterns and Principles
• Modularity & Extensibility: Clearly show the separation between UI, core, and node modules. Indicate extensibility points for custom pipelines and custom nodes.
• MVC/MVVM: Although not strictly enforced, the separation of UI (view, via QML), business logic (core engine), and data (graph and pipeline nodes) is evident. Note the delegation of responsibilities.
• Plugin Architecture: Emphasize how new functionalities (custom nodes) can be added by simply placing them under the correct module and setting the appropriate environment variable.
• Containerization & CI/CD: Represent the Docker configurations and GitHub workflows as part of the project's build, test, and deployment infrastructure.