Edge Processing & Data Sharing in LiDAR Over Mesh Network

A mesh network in LiDAR systems refers to a decentralized communication framework where multiple LiDAR sensors or edge computing nodes communicate directly with each other to share data efficiently. In the mesh network, edge processing and data sharing play a crucial role in reducing latency, improving real-time decision-making, and optimizing bandwidth usage. This is particularly important in autonomous systems, robotics, and smart infrastructure, where multiple LiDAR sensors need to collaborate efficiently.

Decentralized Communication

• Unlike traditional hub-and-spoke networks (where data flows to a central processor), a LiDAR mesh network allows sensors to communicate peer-to-peer.
• Each LiDAR node (sensor or computing unit) relays data to its nearest neighbor, forming a self-healing and scalable network.

Multi-Node Data Fusion

• Multiple LiDAR sensors distributed across an environment or vehicle fleet can exchange point clouds to build a more comprehensive 3D map.
• This enhances situational awareness by reducing blind spots and increasing redundancy.

Edge Processing & Data Sharing

• Mesh networks allow edge computing nodes (like an onboard AI processor) to process LiDAR data locally and share insights with other nodes.
• This reduces latency and computational burden on a central server.

Self-Healing & Redundancy

• If one LiDAR node fails, the data reroutes through other nodes, maintaining the integrity of the system.
• This is particularly useful for autonomous systems operating in dynamic or unpredictable environments.

Wireless & Wired Communication

• Some LiDAR mesh networks use wireless communication protocols (Wi-Fi, UWB, 5G, or V2V/V2X) to transfer data between nodes.
• Others employ high-speed wired connections like Ethernet or CAN bus for reliable data transfer in vehicles.

Edge Processing in LiDAR Mesh Networks

Edge processing refers to processing LiDAR data at or near the source (sensor or edge computing unit) rather than transmitting all raw data to a central cloud or server. This reduces latency and bandwidth consumption while enabling faster decision-making.

How It Works?

• LiDAR sensors collect 3D point clouds: Each sensor generates millions of points per second, mapping the surrounding environment.
• Local processing at edge nodes: Edge processors (embedded GPUs, TPUs, or FPGAs) within the LiDAR unit or connected hardware perform initial data processing, such as:

1. Point cloud filtering (removing noise and irrelevant data)

2. Object detection & classification (identifying obstacles, pedestrians, vehicles)

3. Feature extraction (detecting road lanes, landmarks, or signs)

4. Local SLAM (Simultaneous Localization and Mapping) for real-time navigation

• Data compression & prioritization: Instead of sending full raw LiDAR data, only processed or high-priority data is sent to other nodes in the mesh network.

Data Sharing in a LiDAR Mesh Network

Purpose of Data Sharing

• Enhance coverage & situational awareness: Multiple LiDAR sensors covering different angles and locations share data to build a more complete 3D model.
• Reduce redundant processing: Instead of each node computing everything, they can share results to improve efficiency.
• Improve reliability: If one LiDAR node loses visibility (e.g., blocked by an obstacle), it can request data from neighboring nodes.

Process of Data Sharing

Local Data Fusion & Processing

Each node processes its own LiDAR data and extracts key information (e.g., object positions, velocity, classification).

Peer-to-Peer Communication

LiDAR nodes exchange processed data over the mesh network, using communication protocols like:

• Wi-Fi 6/6E or 5G for high-speed wireless data sharing
• V2V (Vehicle-to-Vehicle) / V2X (Vehicle-to-Everything) for automotive applications
• Ultra-Wideband (UWB) or millimeter-wave (mmWave) for short-range high-speed communication
• Ethernet/CAN Bus for wired vehicle networks

Edge Nodes Aggregate & Integrate Data

• Edge processors combine data from multiple sensors, creating a unified 3D model of the environment.
• Data from multiple viewpoints enhances perception, reducing blind spots and improving accuracy.

Distributed Decision-Making

• Instead of relying on a central server, decisions (such as obstacle avoidance or route planning) are made at the edge, based on shared LiDAR data.
• If a node detects a hazard, it can broadcast alerts to other nodes instantly.

How the Mesh Network can help in Crowd Monitoring & Flow Management

People Detection and Tracking

• Floor Plane Detection: The system first identifies and removes the floor from LiDAR scans to isolate people.
• People Clustering: Using DBSCAN clustering, the system identifies individual people based on point clouds that match human dimensions.
• Temporal Tracking: By matching clusters between consecutive scans, the system tracks individuals over time to calculate movement patterns.

Crowd Density Analysis

• Density Grid: The coverage area is divided into a grid, and the number of people per square meter is calculated for each cell.
• Danger Zone Identification: Areas with crowd density exceeding the threshold (typically 4 people per square meter) are marked as danger zones.
• Zone-Based Monitoring: The venue is divided into logical zones (entrances, corridors, etc.) to monitor occupancy in each area.

Flow Analysis

• Movement Vectors: For each tracked person, the system calculates direction and speed of movement.
• Zone Transitions: The system records when people move between defined zones to understand traffic patterns.
• Flow Conflicts: The system detects areas where people are moving in conflicting directions (>60° angle difference), which can lead to congestion.

Alert Generation

• High Density Alerts: Triggered when crowd density exceeds safe thresholds.
• Slow Movement Alerts: Identifies areas where people are moving abnormally slowly (potential congestion).
• Conflicting Flow Alerts: Highlights areas where people are moving in opposing directions.
• Zone Overcrowding: Alerts when zones approach or exceed their defined capacity.

Mapping For Crowd Monitoring & Flow Management over mesh network

Install Required Libraries

pip install open3d numpy pyzmq scipy        

LiDAR Mesh Network Crowd Monitoring Code

import open3d as o3d
import numpy as np
import zmq
from scipy.spatial import KDTree

# Mesh Network Setup (ZeroMQ for Peer-to-Peer Communication)
context = zmq.Context()
socket = context.socket(zmq.PUB)  # Publish data to other nodes
socket.bind("tcp://*:5555")

# Subscriber to receive data from other nodes
sub_socket = context.socket(zmq.SUB)
sub_socket.connect("tcp://localhost:5555")
sub_socket.setsockopt_string(zmq.SUBSCRIBE, "")

# Load or Simulate LiDAR Point Cloud Data
def load_lidar_data(file="crowd_lidar.ply"):
    pcd = o3d.io.read_point_cloud(file)
    return np.asarray(pcd.points)

# Detect People in Point Cloud
def detect_people(point_cloud, threshold=1.8):
    """
    Filters point cloud data to detect objects around human height.
    """
    human_points = point_cloud[(point_cloud[:, 2] > 0.5) & (point_cloud[:, 2] < threshold)]
    return human_points

# Estimate Crowd Density
def estimate_crowd_density(people_points):
    """
    Uses clustering (KDTree) to count the number of distinct individuals.
    """
    if len(people_points) == 0:
        return 0
    tree = KDTree(people_points[:, :2])  # Use X, Y coordinates
    clusters = tree.query_ball_point(people_points[:, :2], r=0.5)  # Group close points
    return len(set(tuple(map(tuple, people_points[c]))) for c in clusters)

# Compute Flow Direction (Tracking Movement Over Time)
previous_positions = {}

def compute_flow_direction(people_points, frame_id):
    global previous_positions
    flow_vectors = []
    
    if frame_id > 1 and len(previous_positions) > 0:
        for i, point in enumerate(people_points):
            min_dist = float('inf')
            best_match = None
            
            for prev_id, prev_point in previous_positions.items():
                dist = np.linalg.norm(point[:2] - prev_point[:2])
                if dist < min_dist and dist < 0.8:  # Avoid large jumps
                    min_dist = dist
                    best_match = prev_id
            
            if best_match is not None:
                flow_vectors.append(point[:2] - previous_positions[best_match][:2])
    
    # Store current positions for next frame comparison
    previous_positions = {i: p for i, p in enumerate(people_points)}
    
    return flow_vectors

# Main Processing Loop
frame_id = 0

while True:
    frame_id += 1
    print(f"Processing Frame {frame_id}...")

    # Load LiDAR Data
    point_cloud = load_lidar_data()

    # Detect People
    people_points = detect_people(point_cloud)

    # Estimate Crowd Density
    crowd_count = estimate_crowd_density(people_points)
    print(f"Estimated Crowd Size: {crowd_count}")

    # Compute Movement Flow
    flow_vectors = compute_flow_direction(people_points, frame_id)
    print(f"Movement Flow Vectors: {flow_vectors}")

    # Publish Data to Mesh Network
    data_packet = {
        "frame_id": frame_id,
        "crowd_count": crowd_count,
        "flow_vectors": flow_vectors
    }
    socket.send_json(data_packet)

    # Receive Data from Other Nodes
    try:
        received_data = sub_socket.recv_json(flags=zmq.NOBLOCK)
        print(f"Received Data from Network: {received_data}")
    except zmq.Again:
        pass  # No message received yet