A Modern Library for 3D Data Processing

Homepage | Docs | Quick Start | Python | C++ | Tutorial | Back to Overview | GitHub

Introduction

ACloudViewer is an open-source library that supports rapid development of software that deals with 3D data. The ACloudViewer frontend exposes a set of carefully selected data structures and algorithms in both C++ and Python. The backend is highly optimized and is set up for parallelization.

Core Features

ACloudViewer includes the following core features:

• 3D data structures: Point clouds, meshes, octrees, and more
• 3D data processing algorithms: Filtering, segmentation, registration, surface reconstruction
• Scene reconstruction: Multi-view stereo, structure from motion
• 3D visualization: Interactive 3D viewer with Qt-based GUI
• Point cloud I/O: Support for PCD, PLY, LAS, E57, and many other formats
• Mesh I/O: Support for OBJ, STL, OFF, and more
• Plugin system: Extensible architecture for custom algorithms
• Integration with PCL: Seamless interoperability with Point Cloud Library
• Cross-platform: Available on Linux, macOS, and Windows
• Available in C++ and Python: Full API for both languages

Architecture

ACloudViewer is organized into several key modules that work together to provide a complete 3D data processing pipeline:

Figure 1: ACloudViewer architecture showing the different layers and how they fit together to enable full end-to-end pipelines.

💡 Architecture Highlights:
• Layered Design: Clear separation between application, plugins, core processing, and foundation layers
• Extensibility: Plugin system allows adding new file formats and algorithms without modifying core
• Integration: Seamless interoperability with PCL, VTK, Qt, and other industry-standard libraries
• Dual API: Full functionality available in both C++ and Python

Detailed Architecture

┌───────────────────────────────────────────────────────────────────────────────┐
│                         ACloudViewer Application                       │
│                   (ACloudViewer, CloudViewer, Python Bindings)                │
└─────────────────────────────────┬─────────────────────────────────────────────┘
                                  │
               ┌──────────────────┴──────────────────┐
               │                                     │
┌──────────────▼────────────────┐   ┌───────────────▼────────────────┐
│       Plugin System    │   │    Visualization Layer  │
│   (IO + Standard Plugins)     │   │    (Vtk-based 3D Viewer)       │
│                               │   │                                │
│ • qLASIO, qE57IO, qDracoIO    │   │ • Interactive 3D rendering     │
│ • qCSF, qM3C2, qPoissonRecon  │   │ • Scene graph management       │
│ • qPCL, qCanupo, qTreeIso     │   │ • User interactions            │
└──────────────┬────────────────┘   └───────────────┬────────────────┘
               │                                     │
               └──────────────────┬──────────────────┘
                                  │
┌─────────────────────────────────▼───────────────────────────────────────────┐
│                        Core Processing Layer                         │
│                                                                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
│  │ cloudViewer  │  │   CV_db     │  │   CV_io     │  │  PCLEngine   │     │
│  │              │  │              │  │              │  │              │     │
│  │ • ccPoint    │  │ • Database   │  │ • File I/O   │  │ • PCL        │     │
│  │   Cloud      │  │   Management │  │   (PCD,PLY,  │  │   Integration│     │
│  │ • ccMesh     │  │ • Entity     │  │    LAS,E57)  │  │ • Filtering  │     │
│  │ • ccHObject  │  │   Hierarchy  │  │ • Format     │  │ • Registr.   │     │
│  │ • ccOctree   │  │ • Scene Mgmt │  │   Converters │  │ • Segment.   │     │
│  └──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘     │
│                                                                             │
│  ┌────────────────────────────────────────────────────────────────────────┐ │
│  │                      Reconstruction Module                      │ │
│  │   • Surface Reconstruction  • Mesh Generation  • Poisson Recon         │ │
│  └────────────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
                                  │
┌─────────────────────────────────▼───────────────────────────────────────────┐
│                          Foundation Layer                            │
│                                                                             │
│  • Eigen (Linear Algebra)     • Qt (GUI & Widgets)                          │
│  • PCL (Point Cloud Library)  • Boost (Utilities)                           │
│  • VTK (Visualization)         • OpenMP (Parallelization)                   │
│  • CGAL (Geometric Algorithms)                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Data Flow:
  Input Files → CV_io → Core Structures → Processing (Plugins/PCL) → 
  Visualization/Output → Export (CV_io)

Extension Points:
  • Plugin System: Add custom I/O formats and processing algorithms
  • Python API: Script automation and batch processing
  • PCL Integration: Leverage PCL's extensive algorithm library

Here's a brief overview of the different components and how they fit together to enable full end-to-end pipelines:

Core Modules

• cloudViewer: Core point cloud and mesh data structures
  • ccPointCloud - Main point cloud class
  • ccMesh - Triangle mesh representation
  • ccHObject - Hierarchical object model
  • ccGenericPointCloud - Abstract point cloud interface
• CV_db: Database and entity management for complex 3D scenes
• CV_io: I/O operations for various file formats (PCD, PLY, LAS, E57, OBJ, STL, etc.)
• PCLEngine: Integration with Point Cloud Library (PCL)
  • Filtering algorithms
  • Registration (ICP, NDT)
  • Segmentation
  • Surface reconstruction
• Reconstruction: 3D reconstruction algorithms
  • Surface reconstruction
  • Mesh generation
  • Poisson reconstruction

Plugin System

• CVPluginAPI: Plugin interface definitions
  • ccStdPluginInterface - Standard plugin interface
  • ccIOPluginInterface - I/O plugin interface
  • ccPclPluginInterface - PCL plugin interface
• Plugins: Standard plugin implementations for various algorithms

Application Layer

• CVViewer: Standalone 3D viewer application
• ACloudViewer: Main ACloudViewer application with full GUI

C++ Quick Start

Basic Usage

#include <ccPointCloud.h>
#include <FileIOFilter.h>
 
int main() {
    // Load a point cloud
    ccPointCloud* cloud = FileIOFilter::LoadFromFile(
        "cloud.pcd", 
        CC_SHIFT_MODE::AUTO,
        nullptr
    );
    
    if (cloud) {
        std::cout << "Loaded " << cloud->size() << " points" << std::endl;
        
        // Process the point cloud
        // ... your code here ...
        
        delete cloud;
    }
    
    return 0;
}

CMake Integration

cmake_minimum_required(VERSION 3.15)
project(MyCppApp)
 
find_package(ACloudViewer REQUIRED)
 
add_executable(my_app main.cpp)
target_link_libraries(my_app PRIVATE 
    ACloudViewer::Core 
    ACloudViewer::IO
)

Python Quick Start

Pre-built pip packages support Ubuntu 20.04+, macOS 10.15+ and Windows 10+ (64-bit) with Python 3.8-3.11.

# Install
pip install cloudViewer
 
# Verify installation
python -c "import cloudViewer; print(cloudViewer.__version__)"
 
# Python API example
python -c "import cloudViewer as cv3d; \
    cloud = cv3d.io.read_point_cloud('cloud.pcd'); \
    print(f'Loaded {len(cloud.points)} points')"

Compiling from Source

To compile ACloudViewer from source, please refer to the compilation guide.

For detailed build instructions:

• Building from Source
• Platform-Specific Build Guides

Visualization Examples

ACloudViewer provides powerful 3D visualization capabilities for interactive data exploration:

Main Application Interface

ICP Registration Example

3D Surface Reconstruction

Semantic Annotation

Resources

Examples

• C++ examples: Located in examples/Cpp/ directory
• Python examples: Located in examples/Python/ directory
• Jupyter tutorials: Available in the tutorial section

API Documentation

• C++ API: Browse the complete API reference using the navigation above
  • cloudViewer - Core Module
  • CV_db - Database Module
  • CV_io - I/O Module
  • Classes, Namespaces, Files tabs for detailed navigation
• Python API: See the Python API documentation

Communication Channels

• GitHub Repository: https://github.com/Asher-1/ACloudViewer
• Issues: https://github.com/Asher-1/ACloudViewer/issues
• Releases: https://github.com/Asher-1/ACloudViewer/releases

Citation

Please cite our work if you use ACloudViewer:

@software{acloudviewer2024,
  title = {ACloudViewer: A Modern Library for 3D Data Processing},
  author = {ACloudViewer Development Team},
  year = {2024},
  url = {https://github.com/Asher-1/ACloudViewer}
}

License

ACloudViewer is released under the MIT License. See LICENSE file for details.

---

Generated by Doxygen. For the most up-to-date documentation, visit https://asher-1.github.io/ACloudViewer/documentation/