Wear Scar Detection with YOLO, Python and LabVIEW

Why I Built This

In tribological testing (evaluating friction, wear and lubrication on ball-on-disc or pin-on-disk test rigs), measuring the wear scar on a metallic or ceramic test specimen is critical for calculating the wear volume and anti-wear properties of lubricants.

Traditionally, measuring a wear scar is done manually: an operator stares into an optical microscope, manually drags digital calipers across the circular or elliptical crater, and reads the crosshair measurements. This has severe drawbacks:

• Slow and subjective: Measurement repeatability depends heavily on operator fatigue and manual judgment.
• Failure of classical edge detection: Classic thresholding (Otsu, adaptive) and Canny edge detectors struggle because metallic specimens suffer from specular reflections, microscopic grinding scars, variable surface textures, and inconsistent microscope illumination.

To solve this, I designed and deployed an automated optical measurement pipeline: a high-resolution digital microscope takes the picture, a custom-trained YOLO neural network locates the exact scar boundary, and LabVIEW drives the test sequence over a deterministic byte-level binary TCP protocol, converting pixel dimensions to calibrated micrometres (μm).

How the Pieces Fit Together

LabVIEW is the single master executive on the test bench. It knows the exact test sequence, motor positions, and cycle counts. It spawns two independent Python background processes as standalone executables and commands them over TCP sockets.

Step 1: Capturing Images with a Python Live-Stream App

Every high-performance model depends on a rock-solid, consistent dataset. The first application I wrote (livestream10.py) has one critical mission: display the live microscope camera stream and snap an uncompressed, crystal-clear frame whenever LabVIEW issues the trigger.

The dataset goal was 100 to 500 images acquired at calibrated optical magnification and fixed resolution (up to 3840 × 2880), saved with specimen and test IDs.

Internal Architecture:

• Camera Worker Thread: Runs in a dedicated QThread using cv2.VideoCapture(..., cv2.CAP_DSHOW). The thread maintains a single-frame buffer, ensuring LabVIEW never receives a stale frame from hardware queues, and automatically triggers auto-reconnect if 15 consecutive reads fail.
• Frameless Always-on-Top Window: Boots in hidden mode so the executable lives in the background without stealing operator focus until LabVIEW sends a show/restore command.
• Non-blocking TCP Server (Port 5006): A daemon listening thread parses byte commands and uses Qt Signals to cross thread boundaries safely to the GUI.

Camera Command Set (TCP Port 5006)

The core socket receiver ensures packet boundary integrity by enforcing a 3-byte header protocol:

# Big-endian packet parsing with socket framing protection
header = conn.recv(3)
cmd = header[0]
payload_len = int.from_bytes(header[1:3], "big")

# Enforce stream completeness
payload_raw = self.recv_exact(conn, payload_len)
payload = payload_raw.decode("utf-8", errors="ignore")

Step 2: Annotating the Scar with LabelMe

Because metallic wear scars have irregular, semi-circular or elliptical geometry with feathering at the boundaries, rectangle bounding boxes during annotation are insufficient. I used LabelMe to annotate the true boundary as a multi-point closed polygon.

{
  "shapes": [
    {
      "label": "scar",
      "points": [
        [412.3, 188.7], [430.1, 175.2], [455.8, 172.0],
        [468.4, 190.5], [462.0, 215.9], [430.6, 222.1],
        [410.2, 205.4]
      ],
      "shape_type": "polygon"
    }
  ],
  "imagePath": "specimen_014.jpg",
  "imageHeight": 480,
  "imageWidth": 640
}

Converting LabelMe JSON to YOLOv5 Format

YOLO requires normalized coordinates in a companion .txt file matching each image: <class_id> <x_center> <y_center> <width> <height> normalized from 0.0 to 1.0.

Step 3: Training YOLOv5 and Exporting best.pt

With images and normalized labels partitioned 80/20 into train/validation folders, fine-tuning is launched:

python train.py --img 640 --batch 16 --epochs 300 \
  --data dataset.yaml --weights yolov5s.pt --cfg yolov5s.yaml

The secret to achieving >98% mAP with only a few hundred images was transfer learning from yolov5s.pt pretrained on MS COCO. The lower convolutional layers already understand edge gradients, texture contrasts, and elliptical profiles.

Network Architecture Deep Dive:

• Backbone (CSPDarknet53): Spatial resolution is downsampled across 5 pyramid stages (640 → 320 → 160 → 80 → 40 → 20) while channel depth scales up. Early layers capture high-frequency wear scar scratches; deeper layers capture macro circular geometry. An SPPF (Spatial Pyramid Pooling - Fast) layer aggregates multi-scale receptive fields.
• Neck (PANet): Path Aggregation Network merges bottom-up detail features with top-down semantic features, maintaining spatial localization accuracy.
• Head: Evaluates three anchor scales with CIoU (Complete Intersection over Union) bounding box regression loss, penalizing aspect ratio discrepancies.
• Augmentation: Mosaic 4-image stitching, random scaling, and color/brightness jitter simulate fluctuating lab lighting conditions.

Step 4: Sub-Micrometre Optical Calibration

Neural networks output pixel coordinates. To obtain engineering units for ISO/ASTM wear scar standards, we must calibrate pixel distance against a certified optical stage micrometer:

The Viewer and Measurement TCP Daemon (Port 5007)

A second PyQt5 application opens the captured image, displays the bounding ellipse and ROI overlay, and exposes measurement endpoints to LabVIEW:

Step 5: Packaging Standalone Windows EXEs

Factory test benches and customer PC deployments must never depend on manual Python environments, CUDA toolkits, or pip dependencies. Both applications are compiled into self-contained Windows binaries using PyInstaller:

pyinstaller --noconfirm --onefile --noconsole livestream10.py

import multiprocessing
if __name__ == '__main__':
    multiprocessing.freeze_support()

Step 6: Driving the Entire Sequence from LabVIEW

LabVIEW initiates the test run, uses System Exec to launch the background executables, and connects via standard LabVIEW TCP sockets.

Binary Packet Specification:

Example: Sending filepath C:\LAB-IQ 150\images\test.png (29 bytes = 0x001D) with command 0x01:

01 00 1D 43 3A 5C 4C 41 42 2D 49 51 20 31 35 30 5C 69 6D 61 67 65 73 5C 74 65 73 74 2E 70 6E 67

End-to-End Automated Test Sequence:

1. Launch & Handshake: LabVIEW starts camera daemon, connects to localhost:5006.
2. Hardware Init: LabVIEW transmits 0x01 (Connect Camera) → 0x02 (Start Stream).
3. Trigger Capture: Specimen reaches cycle count; LabVIEW sends 0x15 (Save Image) with file target.
4. Release Resource: LabVIEW transmits 0x07 (Minimize) to release USB DirectShow handle.
5. Inference & Measure: LabVIEW sends image path to detection viewer (0x01), then requests results (0x13).
6. Report Generation: LabVIEW reads the JSON reply ({"major_um": 421.8, "minor_um": 415.2, "mean_um": 418.5}) and appends values to the certified ASTM test certificate.

Key Engineering Takeaways