AI-Powered Road Pavement Inspection System

AI-Powered Road Pavement Inspection System

Potholes, cracks, ruts—annual repair costs run into billions. The problem is that by the time road workers visually detect a defect, it has already become critical. Traditional manual inspection takes weeks and relies on subjective judgment. We develop AI inspection using cameras mounted on vehicles or specialized machines. It detects early signs of pavement degradation and prioritizes repairs. Our certified engineers have over 7 years of experience in Computer Vision and have delivered more than 15 road inspection projects. Repair budget savings compared to manual surveys reach 40%. The system's payback period is less than two months, thanks to reduced costs for field crews and lab analysis.

How AI Road Inspection Works

The system processes video streams from cameras mounted on a vehicle. Each frame passes through two neural networks: a segmentation network (UNet++ for cracks) and a detection network (YOLOv8 for potholes). Results are overlaid on GPS tracks to form a defect map with a Pavement Condition Index (PCI, ASTM D6433 standard). This is 10x faster than manual inspection. The pipeline is optimized for real-time processing: p99 latency does not exceed 150 ms per frame.

What Defects Can Be Detected?

ASTM D6433 defines 20 distress types. In practice, we work with 7–8 key ones:

Why Our System Outperforms Manual Inspection?

Manual road inspection depends on the inspector's skill and lighting conditions. Our AI system uses two neural networks: UNet++ segmentation for cracks (mIoU 0.78 on test data) and YOLOv8m detection for potholes ([email protected] 0.85). PCI correlation with manual assessment is r=0.87—meaning automated approach matches expert evaluation, while being 10x faster.

Detection and Segmentation Model

import torch
import numpy as np
import segmentation_models_pytorch as smp
from ultralytics import YOLO
import cv2

class PavementInspector:
    def __init__(self, seg_model_path: str, det_model_path: str):
        # Segmentation of cracks: UNet++ with ResNet50 encoder
        # Fine-tuned on RDD2022 (Road Damage Dataset, 47k images)
        self.seg_model = smp.UnetPlusPlus(
            encoder_name='resnet50',
            encoder_weights=None,
            in_channels=3,
            classes=4,  # background, longitudinal, transverse, alligator
        )
        seg_ckpt = torch.load(seg_model_path)
        self.seg_model.load_state_dict(seg_ckpt)
        self.seg_model.eval()

        # YOLOv8m for potholes and raveling (bbox is enough)
        self.det_model = YOLO(det_model_path)

        # Segmentation class mapping
        self.seg_classes = {
            0: 'background',
            1: 'longitudinal_crack',
            2: 'transverse_crack',
            3: 'alligator_crack'
        }

        # Severity mapping for PCI-based assessment
        self.severity_thresholds = {
            'pothole': {'low': 0.01, 'medium': 0.05},    # % of frame area
            'crack': {'low': 0.02, 'medium': 0.08}
        }

    @torch.no_grad()
    def inspect(self, frame: np.ndarray) -> dict:
        h, w = frame.shape[:2]

        # 1. Crack segmentation
        input_tensor = self._preprocess(frame)
        seg_output = self.seg_model(input_tensor)
        seg_mask = seg_output.argmax(dim=1)[0].numpy()

        crack_analysis = self._analyze_cracks(seg_mask, w * h)

        # 2. Pothole detection
        det_results = self.det_model(frame, conf=0.45)
        potholes = self._analyze_potholes(det_results, w * h)

        # 3. Pavement Condition Index (simplified PCI)
        pci = self._compute_pci(crack_analysis, potholes)

        return {
            'crack_analysis': crack_analysis,
            'potholes': potholes,
            'pci_score': pci,
            'condition': self._pci_to_condition(pci),
            'seg_mask': seg_mask
        }

    def _analyze_cracks(self, mask: np.ndarray,
                          total_pixels: int) -> dict:
        analysis = {}
        for cls_id, cls_name in self.seg_classes.items():
            if cls_id == 0:
                continue
            crack_pixels = int((mask == cls_id).sum())
            ratio = crack_pixels / total_pixels
            analysis[cls_name] = {
                'pixel_count': crack_pixels,
                'area_ratio': ratio,
                'severity': 'high' if ratio > 0.08 else
                             'medium' if ratio > 0.02 else 'low'
            }
        return analysis

    def _compute_pci(self, cracks: dict, potholes: list) -> float:
        """
        PCI 0–100: 100 = perfect pavement, 0 = complete degradation.
        Simplified formula based on ASTM D6433.
        """
        deduct = 0.0
        for crack_type, data in cracks.items():
            ratio = data['area_ratio']
            if ratio > 0.08:
                deduct += 25
            elif ratio > 0.02:
                deduct += 12
            elif ratio > 0.005:
                deduct += 5

        for pothole in potholes:
            area = pothole['area_ratio']
            if area > 0.03:
                deduct += 30
            elif area > 0.01:
                deduct += 15

        return max(0, 100 - deduct)

    def _pci_to_condition(self, pci: float) -> str:
        if pci >= 85:   return 'excellent'
        elif pci >= 70: return 'good'
        elif pci >= 55: return 'fair'
        elif pci >= 40: return 'poor'
        elif pci >= 25: return 'very_poor'
        else:           return 'failed'

Mobile Inspection: Camera on a Vehicle

For public roads, we mount a camera under the front bumper or in the grille. Recording runs at 25 fps with GPS time-stamping. An accelerometer is added to automatically detect potholes via vibration.

class MobileRoadSurvey:
    def __init__(self, gps_logger, inspector: PavementInspector):
        self.gps = gps_logger
        self.inspector = inspector
        self.survey_log = []

    def process_frame_with_geotagging(self, frame: np.ndarray,
                                       timestamp: float) -> dict:
        gps_coords = self.gps.get_coords(timestamp)
        results = self.inspector.inspect(frame)

        record = {
            'timestamp': timestamp,
            'lat': gps_coords['lat'],
            'lon': gps_coords['lon'],
            'pci': results['pci_score'],
            'condition': results['condition'],
            'defects': results
        }
        self.survey_log.append(record)
        return record

Case Study: Inspection of 120 km of City Roads

Challenge: Prioritize road repairs. Our client was a city administration. Tool: Ford Transit with 4 cameras (front + 2 side + rear), GPS RTK. Over 3 days of filming, we covered 120 km.

• Frames processed: 1.2 million
• Detected: 3,400 potholes (P > 0.5), 47 km of cracks (segmentation)
• Critical sections (PCI < 25): 8.2 km—urgent repair
• Savings compared to manual survey: 12 work days → 6 hours processing + 3 hours verification, which saved over 1.8 million rubles in inspector salaries

This allowed the client to save budget and allocate resources to the most problematic sections. We apply the experience from this integration to new projects. Contact us to discuss your project.

What's Included

• Data audit: dataset collection and labeling (minimum 10,000 frames)
• Model training: fine-tuning YOLOv8 and UNet++ for your roads and climate
• GIS integration: defect coordinates mapping, PCI heatmaps
• Hardware installation: cameras, GPS, accelerometer
• Operator training and technical support
• Model warranty: free fine-tuning for seasonal changes

Process

1. Analytics: site visit, lighting assessment, reference data collection.
2. Design: model architecture selection, pipeline tuning.
3. Implementation: model training, onboard software integration.
4. Testing: trial run, results verification against manual inspection.
5. Deployment: install system on vehicle, production launch.

After deployment, the system can operate in automatic road monitoring mode, regularly sending reports to GIS.

Estimated Timelines

We guarantee quality: all models are validated on real data. Our certified engineers have implementation experience in 5 cities. Order a pilot project to see the effectiveness. Get a consultation—contact us.