Instructions:
The project focuses on the use of FMCW radar.
It is used for data collection, point detection, tracking and other functions.
The project is broken down into several modules.
The aim of this division is to decouple as much as possible the functionalities present in each module, and make the development of new functionalities more flexible and rapid.

Some information will be presented to you in json format:
- module: the name of the module
- module_structure: the structure of the module (the files making up the module and their hierarchy)
- module_files_already_generated_doc: the documentation of the module's files if already generated
- other_modules_doc: the documentation of the other modules on which the module depends (possibly none at all)
- gen_doc_of_file: the file you will be given to generate the documentation of. If no file is given, the documentation of the entire module must be generated.
Your goal is to create a markdown documentation of the file you will be given, or the entire module if no file is given.
This documentation is intended to guide a developer who is new to the project, you can therefore add whatever you feel is relevant for this task.


Informations:
{"module": "radar_area_detection", "module_structure": "radar_area_detection/detection.py;radar_area_detection/display.py;radar_area_detection/live_area_detection.py;radar_area_detection\\comm/camera_alert.py;radar_area_detection\\comm/rabbitmq.py;radar_area_detection\\conf/6432_ti_config.cfg;radar_area_detection\\conf/6843_ti_config.cfg;radar_area_detection\\conf/detection_conf.json;radar_area_detection\\conf/live_area_detection.json;radar_area_detection\\conf/rabbitmq_conf.json;radar_area_detection\\conf/tracking_conf.json;", "module_files_already_generated_doc": [{"file": "radar_area_detection\\detection.md", "doc": "# radar_area_detection/detection.py Module Documentation\n\n## Overview\n\nThe detection.py script is part of the radar_area_detection module, which is responsible for the area detection functionality using Frequency Modulated Continuous Wave (FMCW) radar technology. This module aids in the detection of points, tracking, and implementation of alert systems for certain areas within the radar\u00e2\u20ac\u2122s detection range.\n\n## File Structure\n\ndetection.py includes the following classes:\n\n- Area: A simple data structure representing a rectangular detection area.\n- Alert: An abstract base class that defines the structure for raising and clearing alerts.\n- AreaDetector: The primary class that manages detection areas and processes radar data to trigger alerts.\n\n### Area Class\n\nThe Area class serves as a representation of a detection zone, defined by its boundaries in Cartesian coordinates.\n\n#### Attributes\n\n- xl: Float. Represents the x-coordinate of the left boundary of the area.\n- xr: Float. Represents the x-coordinate of the right boundary of the area.\n- yb: Float. Represents the y-coordinate of the bottom boundary of the area.\n- yt: Float. Represents the y-coordinate of the top boundary of the area.\n\n#### Methods\n\n- serialize: Serializes area\u00e2\u20ac\u2122s attributes into a dictionary format.\n\n### Alert Abstract Class\n\nThe Alert class provides a blueprint for implementing the alert system that will respond to detection events.\n\n#### Methods (Abstract)\n\n- RaiseAlert: Abstract method to be defined to specify the actions required when an alert is raised.\n- ClearAlert: Abstract method to be defined to specify the actions required when an alert is cleared.\n\n### AreaDetector Class\n\nAreaDetector is the central class that orchestrates the area detection and alerting process.\n\n#### Constructor\n\n- __init__(areas, alerts=None): Initializes the detector with a list of areas and optional alert mechanisms.\n\n#### Attributes\n\n- alerts: List of Alert objects. Used to handle alerts when a tracked object enters a detection area.\n- areas: List of Area objects. These define the detection areas within the radar\u00e2\u20ac\u2122s field of view.\n- ok_areas: List of Area objects that are considered clear of tracked objects.\n- alert_areas: List of Area objects where alerts have been triggered due to the presence of tracked objects.\n- alert_triggered: Boolean indicating if an alert has been triggered.\n\n#### Methods\n\n- update(clusters_up_to_date): Updates the state of each detection area based on the latest tracked clusters information.\n- serialize: Serializes the status of ok_areas and alert_areas into a dictionary format.\n\n## Integration with Other Modules\n\nThe detection.py script in the radar_area_detection module works in coordination with the radar_tracking module (tracks objects detected by the radar) and may utilize the alerting infrastructure provided by the radar_area_detection\\comm submodule (for example, sending messages via RabbitMQ).\n\n## Usage\n\nDevelopers can use this script to define detection areas, integrate tracking data, and manage alert systems based on their specific needs in the context of FMCW radar applications.\n\n## Data Flow\n\nThe AreaDetector class initializes with predefined detection areas and has the capability to receive real-time tracking data. Upon receipt of new cluster information, the update method reevaluates and categorizes each area as clear or under alert, triggering the appropriate alert mechanisms if any are in place.\n\n## Developer Notes\n\n- When creating new Area instances, ensure that the coordinates correctly reflect the detection zone intended for monitoring.\n- When implementing concrete alert classes, define clear procedures for both RaiseAlert and ClearAlert methods.\n- During the update process, ensure that the centroid of clusters is being correctly obtained from the tracking data.\n- It is crucial to manage ok_areas and alert_areas accurately, reflecting the radar\u00e2\u20ac\u2122s real-time assessment of the monitored areas."}, {"file": "radar_area_detection\\display.md", "doc": "# display.py - radar_area_detection Module Documentation\n\n## Overview\n\nThe display.py script is part of the radar_area_detection module, which integrates with the area detection and object tracking functionalities. This script specifically provides visualization capabilities, extending the TrackingDisplay2D class from the radar_tracking module to represent detection areas and the status of those areas (either as \"ok\" or under \"alert\").\n\n## File Structure\n\ndisplay.py includes the following class:\n\n- AreasDisplay2D: Extends the TrackingDisplay2D class to display detection areas and denote their status on a 2D plot.\n\n### AreasDisplay2D Class\n\nThe AreasDisplay2D class is responsible for visualizing areas on a 2D display, differentiating between areas that are clear (ok) and those that have an active alert. It allows real-time updates of the visualization as the status of the areas changes according to the radar data.\n\n#### Constructor\n\n- __init__(self, *args, **kwargs): Initializes the AreasDisplay2D class with arguments passed to its superclass and initializes an empty list for patches.\n\n#### Attributes\n\n- patches: List. Stores the drawing patches corresponding to areas on the display.\n\n#### Methods\n\n- _prepare_draw(self, clusters, ok_areas: List[Area], alert_areas: List[Area]): Internally prepares the drawing of the clusters and areas. It removes any existing patches and re-adds them according to the updated area states.\n- show(self, clusters, area_detector: AreaDetector): Public method to display the radar clusters and areas. This method calls _prepare_draw with the ok_areas and alert_areas from an AreaDetector instance and then proceeds to draw the updated visualization.\n\n### Integration with Other Modules\n\nThe detect.py script in the radar_area_detection module interacts with the AreasDisplay2D class to visualize active areas and alerts. Moreover, the AreasDisplay2D class uses functionality from the radar_tracking module\u00e2\u20ac\u2122s visualization utilities, signifying how various modules within the system come together to fulfill the project\u00e2\u20ac\u2122s overall objectives.\n\n## Usage\n\nDevelopers can instantiate the AreasDisplay2D class to visualise the area detection results in the context of FMCW radar applications. This enables a graphical representation of which areas are clear (ok) and which are under alert.\n\n## Data Flow\n\n1. An instance of AreasDisplay2D is created with appropriate arguments.\n2. Radar data (clusters) and area statuses are processed by an AreaDetector.\n3. Area statuses and clusters are passed to the AreasDisplay2D instance\u00e2\u20ac\u2122s show method.\n4. The show method updates the visual representation according to the current state of detection areas and tracked clusters.\n\n## Developer Notes\n\n- Use the AreasDisplay2D class to create a visual feedback loop for area detection and alert visualization in real-time radar applications.\n- Ensure active areas and their statuses are correctly updated and reflected in the visualization to provide continuous situational awareness.\n- The visual representation is crucial for debugging and monitoring the radar area detection functionality, hence strive for clear visual distinction between different states for better readability and interpretation.\n\n## Conclusion\n\ndisplay.py within the radar_area_detection module serves a pivotal role in visually representing the status of detection areas in real-time. The AreasDisplay2D class demonstrates an effective integration of visualization techniques with radar detection and tracking capabilities. It contributes to the wider goal of creating a modular and adaptable system for FMCW radar applications."}, {"file": "radar_area_detection\\comm\\camera_alert.md", "doc": "# camera_alert.py - radar_area_detection.comm Module Documentation\n\n## Overview\n\nThe camera_alert.py script resides within the radar_area_detection.comm submodule of the radar_area_detection module. This script defines a concrete implementation of an alert system based on camera activation, which integrates with the radar area detection system to respond to specific detection events using web requests.\n\n## File Structure\n\ncamera_alert.py contains the following class:\n\n- CameraAlert: This class extends the abstract base Alert class, specifying actions to perform when an alert must be raised or cleared via camera control.\n\n### CameraAlert Class\n\nThe CameraAlert class is designed to send commands to a networked camera to start or stop recording based on area detection alerts.\n\n#### Constructor\n\n- __init__(self, ip, port): Initializes the CameraAlert with network configurations.\n\n#### Attributes\n\n- ip: String. The IP address of the camera.\n- port: Integer. The port number to access the camera.\n\n#### Methods\n\n- RaiseAlert: Sends an HTTP POST request to the camera\u00e2\u20ac\u2122s server to start recording when an alert is raised.\n- ClearAlert: Sends an HTTP POST request to the camera\u00e2\u20ac\u2122s server to stop recording when an alert is cleared.\n\n## Integration with Other Modules\n\n- CameraAlert extends the Alert class from radar_area_detection.detection, linking camera control to the area detection logic using polymorphism.\n\n## Usage\n\nThe CameraAlert class may be instantiated and passed to AreaDetector instances within detection.py to specify that the camera should react to detection events.\n\nDevelopers can use this script as follows:\n\n1. Instantiate the CameraAlert with the appropriate IP and port for the camera.\n2. Integrate the instance with the area detection system so the camera actions are triggered during alert conditions.\n\n## Error Handling\n\nThis script catches exceptions during the HTTP request process and prints an error message, which helps to identify network or camera accessibility issues.\n\n## External Dependence\n\ncamera_alert.py depends on the requests library to perform HTTP requests. Make sure that requests is installed and available in the project\u00e2\u20ac\u2122s environment.\n\n## Data Flow\n\n1. The area detection system determines that an alert condition is met.\n2. AreaDetector triggers the RaiseAlert method on the CameraAlert instance.\n3. CameraAlert sends an HTTP request to the camera to start or stop recording based on the state of the alert.\n\n## Developer Notes\n\nDevelopers looking to further customize behavior or add features should consider:\n\n- Expanding the CameraAlert class to handle more sophisticated network protocols or add authentication as needed.\n- Implementing retry logic or asynchronous requests if the synchronous POST request model proves to be a bottleneck or if the timeout parameter needs adjustment.\n- Adding logging mechanisms to capture successful interactions and failed attempts for better operational visibility.\n\n## Conclusion\n\nThe camera_alert.py script effectively bridges the gap between radar area detection and physical security measures, empowering the system to take real-world, automated actions in response to detection events. By following the robust design principle of extending an abstract base class, this module enhances the flexibility and scalability of the overall radar area detection mechanism."}, {"file": "radar_area_detection\\comm\\rabbitmq.md", "doc": "# rabbitmq.py - radar_area_detection.comm Module Documentation\n\n## Overview\n\nThe rabbitmq.py script is part of the communication (comm) submodule within the radar_area_detection module. This script contains a class responsible for interfacing with RabbitMQ to send messages, typically used to alert when an object is detected within a specified area by the radar system.\n\n## File Structure\n\nrabbitmq.py includes the following class:\n\n- RabbitMQSender: A class to manage the connection and message dispatch through RabbitMQ.\n\n### RabbitMQSender Class\n\nRabbitMQSender establishes a RabbitMQ connection and allows sending JSON formatted messages to a specified queue.\n\n#### Constructor\n\n- __init__(self, host, port, queue, exchange): Takes in needed RabbitMQ parameters and initializes the RabbitMQSender.\n\n#### Attributes\n\n- host: String. The IP address or hostname of the RabbitMQ server.\n- port: Integer. The port number for the RabbitMQ server.\n- queue: String. The name of the queue to which messages will be sent.\n- exchange: String. The exchange associated with the message routing.\n\n#### Methods\n\n- connect: Establishes a connection to the RabbitMQ server and declares the queue.\n- send_json(self, data): Publishes a JSON-formatted message to the queue.\n- disconnect: Closes the connection to the RabbitMQ server.\n\n## Integration with Other Modules\n\n- This communication class is a standalone tool within the radar_area_detection module. It can be used in conjunction with the area detection logic to automatically send notifications or alerts over a network when certain conditions are met.\n\n## Usage\n\nDevelopers can instantiate RabbitMQSender as needed to send messages to RabbitMQ brokers that other systems or services can receive. These messages may carry data about detection events or status changes.\n\n## Message Flow\n\n1. An instance of RabbitMQSender is created with the necessary connection parameters.\n2. The class connects to the RabbitMQ server and ensures the queue\u00e2\u20ac\u2122s existence.\n3. JSON data is sent to the queue via send_json.\n4. Upon completion or as part of cleanup, the connection is closed with disconnect.\n\n## Developer Notes\n\n- Ensure that the RabbitMQ server settings (host and port) and queue details are accurately configured.\n- Implement error handling for potential exceptions during connection establishment, message publishing, or disconnection.\n- Consider implementing a context manager protocol (__enter__ and __exit__) for RabbitMQSender to manage connections more gracefully in a with statement.\n- When deploying in a production environment, consider additional mechanisms for robustness, such as connection retries and message delivery confirmations.\n\n## External Dependence\n\nrabbitmq.py depends on the pika library, which facilitates RabbitMQ interactions from Python applications. Ensure that the pika library is incorporated within the project\u00e2\u20ac\u2122s environment.\n\n## Conclusion\n\nThe rabbitmq.py script is a utility class enabling the radar_area_detection module to leverage RabbitMQ for transmitting messages related to radar area detection events. Its simplicity and focus allow for flexible and easy integration into the radar system\u00e2\u20ac\u2122s alerting and notification logic. As part of the module\u00e2\u20ac\u2122s decoupled communication strategy, it supports the overarching project\u00e2\u20ac\u2122s goal of rapid and adaptable development for FMCW radar applications."}], "other_modules_doc": [{"module": "radar_visuals", "doc": "# radar_visuals Module Documentation\n\n## Overview\n\nThe radar_visuals module is a dedicated visualization package within a project focused on the use of Frequency Modulated Continuous Wave (FMCW) radar. It is designed to provide tools and utilities for the rendering of radar data in various visual formats, supporting functionalities like data collection, point detection, and tracking analysis. The module aims to facilitate rapid development and integration of new visualization features through a decoupled and flexible structure.\n\n## Module Structure\n\nThe radar_visuals module currently contains the following file:\n\n- display.py: A Python script offering a suite of classes and functions for creating dynamic and static displays for radar data visualization.\n\n## Module Files Documentation\n\n### display.py\n\nThe display.py file within the radar_visuals package encompasses multiple visualization methods and is central to the module. Below is a summary of the provided documentation:\n\n#### Overview\nThe script is essential for visualizing radar data and includes capabilities for 2D, 3D, and polar plotting. It is versatile enough to accommodate both real-time and static data presentations.\n\n#### Components\nEnums such as PlayingMode, Projection, and GraphType allow the user to define the display behavior, the plot\u00e2\u20ac\u2122s projection type, and the graph style, respectively. Along with utility functions like color_from_id and plot_signal, the script provides two main classes:\n\n- UpdatableDisplay: The abstract base class for displays that can be updated, initializing the figure, axes, and other graphical elements.\n- SimpleUpdatableDisplay: A concrete implementation of UpdatableDisplay that prepares and updates displays with new data points.\n\n#### Functionalities\nThe primary functionalities include creating interactive graphs to visualize radar data, updating them according to predefined playing modes, and ensuring compatibility with different data types and visual projections.\n\n#### Data Flow\nThe typical workflow involves:\n1. Initializing a display object with the required properties.\n2. Accumulating or simulating radar data points.\n3. Updating the display as new data arrives through the show() method.\n4. Presenting the visual representation of the radar data to users based on the set playing mode.\n\n#### Developer Notes\nDevelopers are advised to match data dimensions with graph types and projections, manage update rates effectively, and assign unique colors to data sources using UUIDs for better data distinction.\n\n#### Integration\nDespite being part of the radar_visuals package, display.py operates independently from other components, specifically focusing on visualization purposes and not on signal processing.\n\n## Usage\n\nThe module can be employed to:\n\n- Visualize FMCW radar-related data points, signals, and more complex datasets.\n- Develop new visualization tools tailored to the specifics of radar data.\n- Enhance the interpretation of radar data through graphically rich plots.\n\n## Conclusion\n\nradar_visuals is a crucial module for the graphical representation and analysis of radar data within a larger FMCW radar-focused project. The modular structure accommodates efficient development, enabling users and developers to easily integrate new visualization techniques suited to their specific needs. The module\u00e2\u20ac\u2122s design streamlines the translation of complex data into understandable and insightful visual formats, supporting a wide range of functionalities from debugging to presentation."}, {"module": "radar_toolbox", "doc": "# radar_toolbox Module Documentation\n\n## Overview\n\nThe radar_toolbox module is a collection of tools designed for interfacing with Frequency Modulated Continuous Wave (FMCW) radar systems. It is utilized for various purposes such as data collection, point detection, tracking, and other radar signal processing functions. The module is structured to decouple functionalities into distinct units to promote flexibility and rapid development of new features.\n\n## Module Structure\n\nThe radar_toolbox module is composed of the following elements:\n\n- conf/\n  - Various configuration files setting parameters for radar initialization and different processing steps, such as profile_vs1642_exp.cfg which provides specific settings for radar models and data handling.\n- capture_session/\n  - This submodule contains scripts for setting up and managing radar data capture sessions, with scripts like main.py for starting, monitoring, and saving raw radar captures.\n- raw_data/\n  - A collection of code dealing with raw data handling, including adc.py for interfacing with Analog-to-Digital Converters and scripts to convert raw binary radar data into structured formats for analysis.\n- TI_data/\n  - Contains tools and scripts to communicate, configure, and process data from Texas Instruments (TI) mmWave radar boards, including sensor_com.py which outlines communication protocols and data parsing mechanisms.\n- fmcw_utils.py\n  - This utility file offers essential classes and functions for the processing and analysis of FMCW radar data, such as radar model enums and functions for loading and converting radar data.\n- utils.py\n  - General utility functions and classes that support the operation of the radar_toolbox module, with methods for loading configurations, data parsing, and more.\n\n## Module Files Documentation\n\nDevelopers new to radar_toolbox will find documentation for several key files within the module. An outline of this documentation includes:\n\n- fmcw_utils\n  - Detailed information on handling FMCW radar systems, managing configurations, processing radar signals, and transforming them into analyzable forms.\n- utils\n  - A comprehensive overview of utility functions that aid in loading configurations, preprocessing radar data, and assisting with model training and coordinate adjustments.\n- capture_session/main\n  - Instructions on setting up and conducting recording sessions with scripts that interact with the radar system to initiate and manage data capture.\n- raw_data/adc\n  - Documentation of the adc.py script which serves as an interface to ADC hardware, allowing for the capture and real-time processing of radar data streams.\n- raw_data/raw_bin_to_numpy\n  - Explains the process of converting raw binary radar data into a NumPy array and the steps involved in ensuring data integrity during conversion.\n- raw_data/record_raw_data\n  - A guide to a script focused on raw data recording, detailing the initiation of data capture and subsequent data stream management.\n- TI_data/record_ti_data\n  - Documentation for a script specific to TI radar hardware, describing real-time data capture and CSV data storage functionality.\n- TI_data/sensor_com\n  - Communication protocols and data structure parsing methods for TI mmWave radar boards are outlined for managing interactions with these devices.\n\n## Usage\n\nDevelopers can use the radar_toolbox module to:\n\n- Set up FMCW radar data capture sessions.\n- Record and process raw radar data.\n- Convert binary radar data captures into formats suitable for analysis, such as NumPy arrays.\n- Interact and configure TI mmWave radars for data acquisition.\n\n## Data Flow Summary\n\nThe data flow within the radar_toolbox module follows these general steps:\n\n1. Configuration is set up using JSON files and configuration profiles for the specific radar models.\n2. Data recording sessions are initiated, capturing the radar data and storing it in binary format.\n3. Raw binary data is processed, filtered, and organized into structured data arrays.\n4. Data is made ready for analysis, transformed into point clouds or other representations necessary for further processing and interpretation.\n\n## External Dependencies\n\nWhile the module works as an independent toolkit within the project scope, it interfaces with radar hardware and other software modules that handle advanced data analysis, visualization, and machine learning applications.\n\n## Overall Significance\n\nThe radar_toolbox module serves as the foundational toolset for FMCW radar systems, streamlining the process from initial data capture to data preparation for analytics. It emphasizes modularity, making it easier to grow and adapt the project with new functionalities."}, {"module": "radar_tracking", "doc": "# FMCW Radar Tracking Project Documentation\n\n## radar_tracking Module\n\nThe radar_tracking module sits at the heart of the FMCW radar project, providing algorithms and utilities focused on the tracking of objects detected by the radar system.\n\n### Module Structure\n\nThe module is composed of several scripts and a configuration file organized as follows:\n\n- tracking_utils.py: Utilities for configuring and initializing tracking components.\n- conf/tracking.json: A JSON-formatted configuration file specifying parameters for the tracking system.\n- inference/:\n  - example_kalman_filter.py: Perform inference using Kalman filters.\n  - example_tracking.py: An example script demonstrating the tracking process.\n- models/:\n  - kalman.py: Implementations of Kalman filter for state estimation.\n  - tracking.py: The main tracking algorithm handling the temporal correlation of clusters.\n- clustering/:\n  - cluster.py: Data structure for managing clusters of points.\n  - cluster_predictor.py: Class for predicting clustering behavior based on certain algorithms.\n  - optimizer.py: Optimization utilities for clustering performance.\n- algos/:\n  - clustering_algorithm.py: Abstract base algorithms for clustering.\n  - dbscan.py: DBSCAN clustering algorithm implementation.\n  - gaussian_mixture.py: Gaussian Mixture Model clustering implementation.\n  - meanshift.py: Mean Shift clustering algorithm implementation.\n- visuals/display.py: Visualization classes for displaying the tracking data.\n\n### Dependencies\n\nThe radar_tracking module relies on other parts of the FMCW radar project:\n\n- radar_toolbox:\nA toolkit for interacting with the radar hardware and processing raw radar data.\n\n- radar_visuals:\nProvides dynamic and static displays to visualize radar data, which can be helpful to show tracking results in an accessible form.\n\n## Development Notes\n\nDevelopers new to this project will want to familiarize themselves with the radar_tracking module by reviewing existing documentation and code comments.\n\nFor practical understanding, developers are encouraged to interact with example scripts inside the inference subdirectory. They illustrate how the various components come together to achieve object tracking.\n\n## Conclusion\n\nThe radar_tracking module integrates sophisticated algorithms and diverse data sets to track objects with high precision. It exemplifies a well-organized codebase that promotes decoupled architecture, thus expediting the development of innovative functionalities in radar-based tracking systems."}], "gen_doc_of_file": {"path": "radar_area_detection\\live_area_detection.py", "content": "\"\"\"\nLive area detection from TI data.\nRun this script with the following parameters: --conf=conf/area_detection/[config file]\n\"\"\"\nimport math\n\nimport numpy as np\n\nfrom radar_toolbox.fmcw_utils import RadarModel\nfrom radar_toolbox.utils import configure_argument_parser_for_conf_file, load_conf, get_reader_from_config, \\\n    points_inclination_correction\nfrom radar_area_detection.detection import AreaDetector\nfrom radar_area_detection.comm.camera_alert import CameraAlert\nfrom radar_tracking.tracking_utils import get_capture_limits_from_conf, get_clustering_algo_from_conf, \\\n    get_cluster_tracker_from_conf\n\nif __name__ == \"__main__\":\n    args = configure_argument_parser_for_conf_file()\n    config = load_conf(args.conf)\n    rabbitmq_conf = load_conf(config[\"rabbitmq_conf\"])\n    if rabbitmq_conf[\"enable\"]:\n        from radar_area_detection.comm.rabbitmq import RabbitMQSender\n        import json\n\n        rabbitmq_sender = RabbitMQSender(host=rabbitmq_conf[\"host\"], port=rabbitmq_conf[\"port\"],\n                                         queue=rabbitmq_conf[\"queue\"])\n        rabbitmq_sender.connect()\n\n    cfg_file_path = config[\"cfg_file_path\"]\n    radar_model = RadarModel.get_model_from_str(config[\"model\"])\n    min_velocity_detection = config[\"min_point_vel\"]\n    horizontal_inclination = vertical_inclination = None\n    if config[\"horizontal_inclination\"] is not None:\n        horizontal_inclination = math.radians(config[\"horizontal_inclination\"])\n    if config[\"vertical_inclination\"] is not None:\n        vertical_inclination = math.radians(config[\"vertical_inclination\"])\n\n    tracking_conf = load_conf(config[\"tracking_conf\"])\n    frame_grouping_size = tracking_conf[\"frame_grouping_size\"]  # How many frames do we want per step\n    dt = tracking_conf[\"frame_interval\"] * frame_grouping_size  # Delta time between two steps\n    verbose = tracking_conf[\"verbose\"]\n    capture_limits = get_capture_limits_from_conf(config=tracking_conf)\n\n    clustering_algo = get_clustering_algo_from_conf(config=tracking_conf)\n    cluster_tracker = get_cluster_tracker_from_conf(config=tracking_conf)\n    local_display = config[\"local_display\"]\n    if local_display:\n        from matplotlib import pyplot as plt\n        from radar_area_detection.display import AreasDisplay2D\n        from radar_visuals.display import PlayingMode\n\n        areaDisplay = AreasDisplay2D(dt=dt, capture_limits=capture_limits, playing_mode=PlayingMode.NO_WAIT,\n                                     time_fade_out=tracking_conf[\"time_fade_out\"])\n\n    area_conf = load_conf(config[\"area_detection_conf\"])\n    alerts = None\n    if area_conf[\"camera\"][\"enable\"]:\n        camera_alert = CameraAlert(ip=area_conf[\"camera\"][\"ip\"], port=area_conf[\"camera\"][\"port\"])\n        alerts = [camera_alert]\n    area_detector = AreaDetector(areas=area_conf[\"areas\"], alerts=alerts)\n\n    # Configure the serial port\n    reader = get_reader_from_config(config=config)\n    reader.connect(cli_port=config[\"CLI_port\"], data_port=config[\"data_port\"])\n    reader.send_config(cfg_file_path=cfg_file_path)\n    reader.start_sensor(listen_to_data=True)\n\n    try:\n        while True:\n            result = reader.parse_stream(only_points=True)\n            # check if the data is okay\n            if result[\"data_ok\"]:\n                if result[\"detected_points\"] is None:\n                    points = []\n                else:\n                    points = result[\"detected_points\"]\n                    if radar_model == RadarModel.IWR6843AOP and min_velocity_detection is not None:\n                        points = points[np.abs(points[:, 3]) > min_velocity_detection]\n                    points = points_inclination_correction(points[:, :3], horizontal_inclination, vertical_inclination)\n\n                    points = points[np.all(capture_limits[:, 0] < points, axis=1)]\n                    points = points[np.all(points < capture_limits[:, 1], axis=1)]\n\n                # Tracking\n                clusters, noise = clustering_algo.clusterize(points)\n                cluster_tracker.TrackNextTimeStep(current_clusters=clusters, verbose=verbose)\n                # Intrusion detection\n                area_detector.update(clusters_up_to_date=cluster_tracker.tracked_clusters)\n                if local_display:\n                    areaDisplay.show(clusters=cluster_tracker.tracked_clusters, area_detector=area_detector)\n                if rabbitmq_conf[\"enable\"]:\n                    json_data = {\n                        \"areas\": area_detector.serialize(),\n                        \"clusters\": cluster_tracker.serialize()\n                    }\n                    json_data = json.dumps(json_data)\n                    rabbitmq_sender.send_json(json_data)\n    except KeyboardInterrupt:  # Stop the program and close everything if Ctrl + c is pressed\n        pass\n    finally:\n        reader.disconnect()\n        if local_display:\n            plt.close('all')\n        if rabbitmq_conf[\"enable\"]:\n            rabbitmq_sender.disconnect()\n"}}