diff --git a/.codeboarding/Face_Detection_CLI.md b/.codeboarding/Face_Detection_CLI.md
new file mode 100644
index 000000000..72c6d98d4
--- /dev/null
+++ b/.codeboarding/Face_Detection_CLI.md
@@ -0,0 +1,131 @@
+```mermaid
+
+graph LR
+
+ Face_Detection_CLI["Face Detection CLI"]
+
+ Face_Recognition_API["Face Recognition API"]
+
+ Click_Library["Click Library"]
+
+ Multiprocessing_Module["Multiprocessing Module"]
+
+ OS_Module["OS Module"]
+
+ Re_Module["Re Module"]
+
+ Face_Detection_CLI -- "uses" --> Face_Recognition_API
+
+ Face_Detection_CLI -- "uses" --> Click_Library
+
+ Face_Detection_CLI -- "uses" --> Multiprocessing_Module
+
+ Face_Detection_CLI -- "uses" --> OS_Module
+
+ Face_Detection_CLI -- "uses" --> Re_Module
+
+ click Face_Detection_CLI href "https://github.com/ageitgey/face_recognition/blob/main/.codeboarding//Face_Detection_CLI.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+These components are fundamental because they collectively enable the `Face Detection CLI` to function as a complete and efficient tool: 1. **Face Detection CLI**: This is the user-facing entry point. It's fundamental because it provides the accessibility and ease of use for the underlying face detection capabilities, allowing non-programmers to utilize the system. Without it, users would need to write custom scripts. 2. **Face Recognition API**: This is the core engine. It's fundamental because it contains the actual algorithms and logic for face detection. The CLI is merely a wrapper; the API provides the essential functionality that makes the project valuable. 3. **Click Library**: This is fundamental for building a robust and standard command-line interface. It abstracts away the complexities of argument parsing, help message generation, and command dispatching, making the CLI user-friendly and maintainable. 4. **Multiprocessing Module**: This is fundamental for performance. For a task like image processing, which can be computationally intensive, parallelization is crucial. The `multiprocessing` module allows the CLI to leverage multiple CPU cores, significantly speeding up the processing of large image datasets. 5. **OS Module**: This is fundamental for any application that interacts with the file system. The CLI needs to read input files, determine if the input is a single file or a directory, and list files within directories. The `os` module provides these essential file system interaction capabilities. 6. **Re Module**: This is fundamental for input validation and filtering. When processing directories, the CLI needs to identify which files are actual images. The `re` module allows for robust pattern matching to ensure only relevant image files are processed, preventing errors and improving efficiency.
+
+
+
+### Face Detection CLI
+
+This component provides the command-line interface for users to perform face detection on images. It parses command-line arguments, validates input, and orchestrates the calls to the core face detection API. It supports processing single images or entire directories, with an option for parallel processing.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_recognition.face_detection_cli` (1:1)
+
+
+
+
+
+### Face Recognition API
+
+This component encapsulates the core logic and algorithms for face detection. It provides functions to load images and detect face locations within them. It serves as the programmatic interface for face detection capabilities.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_recognition.api` (1:1)
+
+
+
+
+
+### Click Library
+
+An external library used for building command-line interfaces. It simplifies argument parsing, command definition, and user interaction for the `Face Detection CLI`.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Multiprocessing Module
+
+A standard Python library used by the `Face Detection CLI` to enable parallel processing of images across multiple CPU cores, significantly improving performance when handling large sets of images.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### OS Module
+
+A standard Python library used for interacting with the operating system, specifically for file system operations such as checking if a path is a directory, listing directory contents, and joining paths.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Re Module
+
+A standard Python library for regular expressions, used by the `Face Detection CLI` to filter and identify image files (e.g., .jpg, .jpeg, .png) within a given directory.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Face_Recognition_CLI.md b/.codeboarding/Face_Recognition_CLI.md
new file mode 100644
index 000000000..9bb90590f
--- /dev/null
+++ b/.codeboarding/Face_Recognition_CLI.md
@@ -0,0 +1,91 @@
+```mermaid
+
+graph LR
+
+ Face_Recognition_CLI["Face Recognition CLI"]
+
+ Face_Recognition_API["Face Recognition API"]
+
+ CLI_Utility_Functions["CLI Utility Functions"]
+
+ Face_Recognition_CLI -- "depends on" --> Face_Recognition_API
+
+ Face_Recognition_CLI -- "utilizes" --> CLI_Utility_Functions
+
+ click Face_Recognition_CLI href "https://github.com/ageitgey/face_recognition/blob/main/.codeboarding//Face_Recognition_CLI.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+This subsystem is designed to provide a robust command-line interface for recognizing and identifying known individuals in images. It achieves this by first "learning" known faces (generating and storing their encodings) and then comparing new faces against this learned dataset.
+
+
+
+### Face Recognition CLI
+
+This component serves as the primary command-line interface for the face recognition application. It orchestrates the entire workflow, including scanning known individuals, processing input images, and displaying recognition results. It handles user input, manages multiprocessing for efficiency, and integrates with the core face recognition functionalities.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_recognition.api:load_image_file` (77:88)
+
+- `face_recognition.api:face_encodings` (202:213)
+
+- `face_recognition.api:face_distance` (62:74)
+
+- `face_recognition_cli:scan_known_people` (13:31)
+
+- `face_recognition_cli:test_image` (41:63)
+
+- `face_recognition_cli:print_result` (34:38)
+
+- `face_recognition_cli:image_files_in_folder` (66:67)
+
+- `face_recognition_cli:process_images_in_process_pool` (70:91)
+
+
+
+
+
+### Face Recognition API
+
+This component provides the foundational, low-level functionalities for face detection, face encoding, and face comparison. It acts as the core library that the CLI components leverage to perform the actual image processing and facial analysis.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### CLI Utility Functions
+
+These are internal helper functions within the `Face Recognition CLI` component that support its operation. They handle tasks suchs as filtering image files within a folder, printing formatted results to the console, and managing the multiprocessing pool for parallel image processing.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Face_Recognition_Core_API.md b/.codeboarding/Face_Recognition_Core_API.md
new file mode 100644
index 000000000..50a2bc486
--- /dev/null
+++ b/.codeboarding/Face_Recognition_Core_API.md
@@ -0,0 +1,211 @@
+```mermaid
+
+graph LR
+
+ Image_Loader["Image Loader"]
+
+ Face_Detection_Core["Face Detection Core"]
+
+ Facial_Landmark_Core["Facial Landmark Core"]
+
+ Face_Encoding_Model["Face Encoding Model"]
+
+ Face_Distance_Calculator["Face Distance Calculator"]
+
+ Dlib_Model_Initializer["Dlib Model Initializer"]
+
+ Coordinate_Conversion_Utilities["Coordinate Conversion Utilities"]
+
+ Image_Loader -- "Provides input to" --> Face_Detection_Core
+
+ Face_Detection_Core -- "Receives input from" --> Image_Loader
+
+ Face_Detection_Core -- "Provides output to" --> Facial_Landmark_Core
+
+ Face_Detection_Core -- "Utilizes" --> Dlib_Model_Initializer
+
+ Face_Detection_Core -- "Utilizes" --> Coordinate_Conversion_Utilities
+
+ Facial_Landmark_Core -- "Receives input from" --> Face_Detection_Core
+
+ Facial_Landmark_Core -- "Provides output to" --> Face_Encoding_Model
+
+ Facial_Landmark_Core -- "Utilizes" --> Dlib_Model_Initializer
+
+ Facial_Landmark_Core -- "Utilizes" --> Coordinate_Conversion_Utilities
+
+ Face_Encoding_Model -- "Receives input from" --> Facial_Landmark_Core
+
+ Face_Encoding_Model -- "Provides output to" --> Face_Distance_Calculator
+
+ Face_Encoding_Model -- "Utilizes" --> Dlib_Model_Initializer
+
+ Face_Distance_Calculator -- "Receives input from" --> Face_Encoding_Model
+
+ Dlib_Model_Initializer -- "Provides models to" --> Face_Detection_Core
+
+ Dlib_Model_Initializer -- "Provides models to" --> Facial_Landmark_Core
+
+ Dlib_Model_Initializer -- "Provides models to" --> Face_Encoding_Model
+
+ Coordinate_Conversion_Utilities -- "Used by" --> Face_Detection_Core
+
+ Coordinate_Conversion_Utilities -- "Used by" --> Facial_Landmark_Core
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The Face Recognition Core API component, primarily implemented in face_recognition/api.py, serves as the foundational layer for the face_recognition library. It encapsulates the low-level, computationally intensive operations required for face detection, facial landmark identification, and face encoding generation. This component acts as a central engine, exposing high-level functions that abstract away the complexities of underlying computer vision tasks, making it accessible for higher-level applications and command-line interfaces within the library.
+
+
+
+### Image Loader
+
+This component is responsible for loading various image file formats (e.g., JPG, PNG) into a NumPy array, which is the standard data structure for image processing within the library. It ensures images are in a consistent format (e.g., RGB) for subsequent operations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `load_image_file` (78:89)
+
+
+
+
+
+### Face Detection Core
+
+This component implements the primary logic for identifying the bounding boxes of human faces within an image. It supports both the less accurate but faster HOG (Histogram of Oriented Gradients) model and the more accurate, GPU-accelerated CNN (Convolutional Neural Network) model, including batched processing for efficiency.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `_raw_face_locations` (92:151)
+
+- `face_locations` (92:151)
+
+- `_raw_face_locations_batched` (92:151)
+
+- `batch_face_locations` (92:151)
+
+
+
+
+
+### Facial Landmark Core
+
+This component is responsible for pinpointing key facial features (e.g., eyes, nose, mouth, chin outline) within the detected face regions. It uses pre-trained Dlib models (68-point for detailed landmarks or 5-point for faster, less detailed results).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `_raw_face_landmarks` (154:198)
+
+- `face_landmarks` (154:198)
+
+
+
+
+
+### Face Encoding Model
+
+This component leverages a pre-trained Dlib deep learning model to transform the detected facial landmarks into a 128-dimensional face embedding (a unique numerical vector). This embedding captures the distinctive features of a face, making it suitable for comparison.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_encoder` (29:29)
+
+
+
+
+
+### Face Distance Calculator
+
+This component calculates the Euclidean distance between two or more face encodings. The distance value quantifies the similarity between faces, with smaller distances indicating higher similarity.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_distance` (63:75)
+
+
+
+
+
+### Dlib Model Initializer
+
+This component is responsible for loading and initializing the various pre-trained Dlib models required for face detection, facial landmark prediction, and face encoding. It ensures that the underlying C++ libraries and models are ready for use.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Dlib Model Initializer` (17:29)
+
+
+
+
+
+### Coordinate Conversion Utilities
+
+This set of internal helper functions manages the conversion between Dlib's `rect` object format and a more user-friendly CSS-like tuple format (top, right, bottom, left). It also includes utilities to ensure that coordinates remain within the image boundaries.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `_rect_to_css` (32:60)
+
+- `_css_to_rect` (32:60)
+
+- `_trim_css_to_bounds` (32:60)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 000000000..9c9bd65fc
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,93 @@
+```mermaid
+
+graph LR
+
+ Face_Recognition_Core_API["Face Recognition Core API"]
+
+ Face_Detection_CLI["Face Detection CLI"]
+
+ Face_Recognition_CLI["Face Recognition CLI"]
+
+ Face_Detection_CLI -- "uses" --> Face_Recognition_Core_API
+
+ Face_Recognition_CLI -- "uses" --> Face_Recognition_Core_API
+
+ click Face_Recognition_Core_API href "https://github.com/ageitgey/face_recognition/blob/main/.codeboarding//Face_Recognition_Core_API.md" "Details"
+
+ click Face_Detection_CLI href "https://github.com/ageitgey/face_recognition/blob/main/.codeboarding//Face_Detection_CLI.md" "Details"
+
+ click Face_Recognition_CLI href "https://github.com/ageitgey/face_recognition/blob/main/.codeboarding//Face_Recognition_CLI.md" "Details"
+
+```
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Component Details
+
+
+
+The `face_recognition` project is structured around a core API that provides fundamental face processing capabilities, which are then leveraged by two distinct command-line interface (CLI) applications. These three components were chosen because they represent the distinct and critical functionalities within the `face_recognition` project, as identified by both the Control Flow Graph (CFG) and the file structure. `face_recognition.api` (Face Recognition Core API) is fundamental because it is the producer of all core face processing capabilities. Both CLI tools directly depend on it to perform their operations. Its absence would render the entire project non-functional. The CFG clearly shows both CLI components "using" this API. `face_recognition.face_detection_cli` (Face Detection CLI) is fundamental as it serves as a direct application of the core API for a specific, common task: face detection. It provides a user-friendly entry point for this functionality, abstracting away the underlying complexities. `face_recognition.face_recognition_cli` (Face Recognition CLI) is fundamental because it represents the most comprehensive application of the core API, enabling full face identification. This involves not just detection but also learning and comparison, making it a complete solution for a key problem domain. The relationships are clear: both CLI tools act as consumers of the `Face Recognition Core API`, demonstrating a clean separation of concerns between the core logic and its application interfaces. This architecture allows for modularity and reusability of the core face recognition functionalities.
+
+
+
+### Face Recognition Core API
+
+This is the foundational component of the `face_recognition` library. It encapsulates all the low-level, computationally intensive operations related to face detection, landmark identification, and encoding generation. It acts as the central engine, providing essential functionalities that higher-level applications consume.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_recognition/api.py` (0:0)
+
+
+
+
+
+### Face Detection CLI
+
+This component provides a command-line interface specifically designed for detecting face locations within images. It simplifies the process of using the core API's face detection capabilities, allowing users to easily identify faces in single images or entire directories without writing code.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_recognition/face_detection_cli.py` (0:0)
+
+
+
+
+
+### Face Recognition CLI
+
+This component offers a comprehensive command-line tool for recognizing and identifying known individuals in images. It extends beyond simple detection by first "learning" known faces (generating and storing their encodings) and then comparing new faces against this learned dataset to identify individuals.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `face_recognition/face_recognition_cli.py` (0:0)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file