With over 5 years on the market and 30+ successful projects, our team builds video analytics systems for conveyor lines turnkey— from design to deployment. The conveyor video analytics system integrates belt stop detection, product counting, and anomaly detection with high accuracy. We solve tasks that are difficult to automate with other sensors: detection of jammed objects, belt speed monitoring, detection of abnormal situations (jams, spills, product fallouts), and performance counting. One video stream replaces dozens of point sensors, covering the entire observation area. On a beverage bottling line, we reduced unaccounted product by 15%, saving the client 2.5 million rubles per year. Get a consultation on your project.
How video analytics improves conveyor monitoring accuracy?
Belt stop detection: we use optical flow Farneback — a dense method that computes motion vectors for each pixel. This allows detecting even a 10% slowdown from nominal speed. If the average motion vector in the belt region is close to zero, a stop is registered.
Stop detection code
import cv2 import numpy as np class ConveyorMonitor: def __init__(self, config: dict): self.belt_roi = config['belt_roi'] self.normal_speed_range = config['belt_speed_range'] self.alarm_callbacks = [] self.prev_frame = None self.lk_params = dict( winSize=(21, 21), maxLevel=3, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03) ) def process_frame(self, frame: np.ndarray) -> dict: roi_frame = self._crop_roi(frame, self.belt_roi) gray = cv2.cvtColor(roi_frame, cv2.COLOR_BGR2GRAY) analysis = {'timestamp': get_timestamp()} if self.prev_frame is not None: flow = cv2.calcOpticalFlowFarneback( self.prev_frame, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0 ) mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1]) mean_speed = float(np.mean(mag)) analysis['belt_speed'] = mean_speed analysis['belt_status'] = self._check_speed(mean_speed) analysis['obstruction'] = self._detect_obstruction(gray, flow) self.prev_frame = gray.copy() return analysis def _check_speed(self, speed: float) -> str: min_speed, max_speed = self.normal_speed_range if speed < min_speed * 0.1: return 'STOPPED' elif speed < min_speed * 0.5: return 'SLOW' elif speed > max_speed * 1.5: return 'FAST' return 'NORMAL' Product counting on the conveyor
For counting, we use a cascade: YOLOv8s detector (trained on 10,000+ images of various packages) and ByteTracker. An object is counted when its center crosses a virtual line. This eliminates double counting during belt stops. Product counting accuracy of 98–99.5% is 2 times higher than ultrasonic sensors which achieve only 90–95%. Accuracy has been confirmed on 20+ lines.
class ProductCounter: def __init__(self, count_line_y: int, model_path: str): self.detector = YOLO(model_path) self.count_line_y = count_line_y self.tracker = ByteTracker() self.counted_ids = set() self.count = 0 def process(self, frame: np.ndarray) -> int: detections = self.detector(frame, conf=0.5) tracks = self.tracker.update(detections[0]) for track in tracks: cx = int((track.bbox[0] + track.bbox[2]) / 2) cy = int((track.bbox[1] + track.bbox[3]) / 2) if (track.track_id not in self.counted_ids and abs(cy - self.count_line_y) < 10): self.count += 1 self.counted_ids.add(track.track_id) return self.count Why video analytics is more effective than sensors?
Point sensors provide information only at the installation point — they do not see jams or stops outside their zone. Video analytics covers the entire conveyor area: one 4K camera stream replaces dozens of sensors. Additionally, the system detects belt surface anomalies and spills, which are inaccessible to conventional sensors. Our experience — 5+ years in industrial video analytics, over 30 implemented projects — guarantees stable operation in workshop conditions. For example, at a cement plant, our system detected a belt blockage 2 seconds earlier than the operator, preventing 3 hours of downtime worth 150 thousand rubles.
Farneback optical flow method is described in the paper "Two-Frame Motion Estimation Based on Polynomial Expansion" (2003)
Detection of abnormal situations
For surface anomalies, we use the PatchCore model trained on reference images of conveyor belts. It detects any deviations: cracks, foreign objects, contamination. Liquid or bulk material spills are detected by a separate YOLO detector trained on synthetic data with augmentation.
class AnomalyDetector: def __init__(self): from anomalib.models import PatchCore self.model = PatchCore.load('conveyor_anomaly.pt') self.spill_detector = YOLO('spill_detector.pt') def check_belt_surface(self, roi: np.ndarray) -> dict: anomaly_result = self.model.predict(roi) issues = [] if anomaly_result.pred_score > 0.7: issues.append({ 'type': 'surface_anomaly', 'score': float(anomaly_result.pred_score), 'region': self._get_anomaly_region(anomaly_result.anomaly_map) }) spill_results = self.spill_detector(roi, conf=0.4) for box in spill_results[0].boxes: issues.append({ 'type': 'spill', 'bbox': box.xyxy[0].tolist(), 'confidence': float(box.conf) }) return {'has_issues': len(issues) > 0, 'issues': issues, 'severity': 'CRITICAL' if issues else 'OK'} Productivity heat map
Visualization of shift performance: units per hour, conveyor speed dynamics, incidents and their duration. Dashboard on Grafana with metrics from InfluxDB. We can also add belt wear prediction based on historical data.
Integration with MES/SCADA
Analytics results are transmitted to the Manufacturing Execution System via OPC-UA or REST API. Automatic line stop upon critical incidents via PLC. We support protocols OPC-UA (DA, HDA), Modbus TCP, Siemens S7. Data in JSON or Protobuf format for minimal latency.
| Metric | Value |
|---|---|
| Stop detection accuracy | 99.5%+ |
| Product counting accuracy | 98–99.5% |
| Incident detection latency | < 500 ms |
| False alarm rate | < 0.5% |
| System scale | Timeline |
|---|---|
| 1 line, basic monitoring | 4–6 weeks |
| 3–5 lines, anomaly detection | 8–12 weeks |
| Whole workshop, MES integration | 14–20 weeks |
What's included in the work
- Conveyor line audit and equipment selection
- Development of computer vision models (YOLO, optical flow, PatchCore)
- Integration with existing MES/SCADA (OPC-UA, REST API)
- Deployment on industrial server or edge device
- Operator training and documentation
- Post-release support and model retraining
How we implement the system?
Typical implementation stages:
- Conveyor line audit and equipment selection.
- Data collection and training of computer vision models (YOLO, optical flow, PatchCore).
- Development and testing of detection, tracking, and anomaly algorithms.
- Integration with MES/SCADA via OPC-UA or REST API.
- Deployment on industrial server or edge device.
- Operator training and handover of documentation.
- Post-release support and model retraining.
Estimated timelines: for a single line with basic monitoring — 4–6 weeks, for 3–5 lines with anomaly detection — 8–12 weeks, for a whole workshop with MES integration — 14–20 weeks. Exact timelines are calculated after an audit. Typical payback period: 6–12 months.
Order a pilot project on one line to evaluate the effect. Get a consultation on your project — we will estimate the timeline and cost.