How cggos/ccv works
Main Components
• Core Library: Represent the core computer vision modules (e.g., Maths, Computer Vision, Kinematics) built in C++ along with header files (in “include” and “src” directories) that implement low-level algorithms.
• External/Demo Libraries: Indicate the integration points for third-party libraries and dependencies such as OpenCV, FFTW, PCL, OpenGL, and Pangolin. Group these as “Dependencies/External Libraries.”
• Apps/Demos: Create separate nodes for the different application suites. For instance:
– Camera Kit: Further divided into Android Camera App, ROS-based camera utilities, calibration tools (with submodules like “calib_rectify”, “cam_ros”, “rs_cam”, “stereo_cam_mipi”, and “v4l_sdk”).
– CVStudio (GUI on Qt)
– DIP Demos in C# and Java
– Stereo Matching (OpenCL based) and Stereo Reconstruction (ROS based)
– Other smaller demos (e.g., Face Detection)
• Language-Specific Modules: Optionally denote that parts of the project are implemented in multiple languages. For example, a node for “Python LibCCV” and blocks for Matlab, Java, and C# demos.
• Configuration and Build System: Represent the build processes (plain CMake workflows, catkin build for ROS, gradle for Android) as an auxiliary component that ties these components together.
Relationships and Interactions
• For the ROS parts (like cam_ros, stereo_reconstruct, etc.), illustrate how these wrap the core-computer vision functionalities and interact with ROS middleware.
• In the Android and other language-specific modules, indicate that wrappers or bindings link the core C++ functionality with higher-level interfaces.
• Build and deployment flows: e.g., CMake configurations and custom scripts (shell scripts in calibration modules) facilitating various use cases.
Architectural Patterns and Design Principles
• Modularization: Emphasize the separation between core vision functionalities and higher-level application-specific code. The project is organized in a modular fashion where each demo or application is a “client” of the core library.
• Multi-language/Platform support: The architecture is layered such that a fundamental C++ vision library can be accessed via language-specific wrappers (Java, C#, Python).
• ROS and Embedded Integration: Some modules are designed as ROS packages with nodelets that wrap the C++ core, demonstrating a plugin/service-oriented design.
• Use of External Libraries: The design leverages industry-standard libraries (OpenCV, PCL, etc.) to abstract hardware interactions and advanced algorithms.
Technologies, Frameworks, and Libraries
• C++/OpenCV: For core image processing and computer vision routines.
• Build Systems: CMake, Gradle for Android, and ROS catkin tools.
• Scripting and Testing: Shell scripts for calibration routines and unit tests via Google Test.
• Additional graphics/visualization: Qt for CVStudio, Pangolin and OpenGL for visual demos, and GraphViz used in one of the Python demos.
Essential Elements
• Use clear, distinctly labeled nodes for each major component (Core Library, each App Suite, External Libraries, Build/Configuration).
– Data flow (e.g., images processed by the core, then consumed by apps)
– Dependencies (core library depends on external libraries; apps depend on both core library and middleware like ROS)
Construction
• Branch out to connect to external libraries (OpenCV, FFTW, etc.) that serve as dependencies.
• On one side, list all apps (Camera Kit, CVStudio, etc.) built on top of the core. Within the “Camera Kit” node, you may further segment sub-components (calibration, ROS wrappers, Android implementation, etc.).
• Peripheral nodes for language-specific wrappers/demos (Java DIP Demo, C# DIP Demo, Python LibCCV).
• On a separate side, include configuration and build modules (CMakeLists, catkin build commands, Gradle files) to indicate the build and integration process.