Building a DIY Image-Based Part Inspection System: No Expensive Hardware Needed

Democratizing precision measurement with geometry-driven computer vision

This article describes an independent engineering exploration. It does not represent any employer, institution, or commercial product.

High-precision part inspection has traditionally required expensive hardware: coordinate measuring machines (CMMs), optical comparators, laser scanners, or telecentric vision systems. These tools are powerful—but they are also slow, costly, and often inaccessible to small and medium-sized manufacturers.

At the same time, a large portion of real-world inspection tasks are fundamentally 2D geometric problems:

• Measuring hole diameters
• Verifying spacing between features
• Inspecting slots, fillets, chamfers, and outer profiles
• Comparing physical parts against engineering drawings

This gap motivated me to build an image-based part inspection system that extracts geometric features directly from images and converts them into measurable, CAD-ready representations—using only low-cost cameras and computation.

This article explains the engineering pipeline behind that system, why traditional approaches struggle, and how a geometry-first vision architecture enables reliable, high-precision measurement without expensive metrology hardware.

The Core Challenge: Images Are Not Geometry

Engineering drawings assume perfect edges and clean curves. Real images do not.

Even under controlled lighting, images of machined parts suffer from:

• Illumination gradients and reflections

• Surface texture and machining marks

• Broken or partially occluded edges

• Noise from low-cost optics

• Perspective distortion

A single part may contain concentric holes, chamfers, fillets, slots, and partial arcs—often with only fragments of each feature visible.

Naive solutions such as template matching, Hough transforms, or object detection models tend to fail because they operate at the pixel or pattern level, while inspection is a geometric reasoning problem.

To solve this, I designed a pipeline that elevates pixels into geometry as early as possible.

System Overview

The system follows a multi-stage architecture:

1. Image normalization and calibration
2. Precision edge extraction
3. Contour segmentation into geometric primitives
4. Geometry-driven feature recognition
5. Dimensional measurement in calibrated space
6. CAD reconstruction and validation

Each stage aggressively filters noise while preserving geometric meaning.

1. Image Normalization: Stabilizing the Input

Lighting variation is one of the biggest threats to measurement accuracy.

Before any geometry is extracted, the image is normalized using:

• Illumination compensation (low-frequency shading removal)

• Camera calibration and distortion correction

• Contrast enhancement tuned for metal surfaces

  import cv2
  import numpy as np
  
  def normalize_and_undistort(img_gray, K, dist):
      """
      img_gray: grayscale image
      K, dist: camera intrinsics & distortion coefficients
      return: undistorted + illumination-normalized image
      """
      und = cv2.undistort(img_gray, K, dist)
  
      # illumination flattening (remove low-frequency shading)
      low = cv2.GaussianBlur(und, (0, 0), sigmaX=25, sigmaY=25)
      norm = cv2.divide(und, low + 1e-6, scale=255)
  
      return norm.astype(np.uint8)
  
  
  

The goal is not visual beauty, but geometric consistency—straight edges must remain straight, and circular features must not warp.

2. Precision Edge Extraction

Measurement accuracy is limited by edge localization accuracy.

Instead of relying on standard edge detectors alone, the system uses a staged approach:

• Adaptive thresholding

• Edge enhancement filtering

• Morphological cleanup

• Subpixel edge refinement

  ### Precision Edge Extraction
  
  Accurate measurement depends on stable and repeatable edge localization.
  The following simplified snippet illustrates how edge masks are generated
  for subsequent geometric fitting.
  
  ```python
  def extract_edges(img_gray):
      bw = cv2.adaptiveThreshold(
          img_gray, 255,
          cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
          cv2.THRESH_BINARY_INV,
          31, 3
      )
      edges = cv2.Canny(bw, 60, 150)
      return edges
  
  

The output is a thin, continuous edge representation suitable for geometric fitting, even when edges are partially broken.

3. From Contours to Geometry

Once edges are extracted, the system stops thinking in pixels.

Contours are decomposed into geometric primitives, including:

• Lines
• Circular arcs
• Full circles
• Composite features (slots, keyways)

def contours_to_segments(edge_img):
    """
    return: list of polyline segments (each is Nx2 points)
    """
    cnts, _ = cv2.findContours(edge_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
    segments = []
    for c in cnts:
        pts = c.squeeze(axis=1)  # (N,2)
        if len(pts) < 30:
            continue
        segments.append(pts)
    return segments

Each segment is classified based on curvature behavior and validated using robust fitting techniques. Distance-based support checks ensure that fitted geometry is actually supported by the image, rather than being an artifact of noise.

This approach allows the system to recover geometry even when features are incomplete or fragmented.

4. Geometry-Driven Reasoning (The Critical Layer)

This is where the system differentiates itself from most vision pipelines.

Instead of detecting features independently, it reasons about relationships between primitives:

• Concentric circles are grouped to identify counterbores or countersinks

• Line–arc–line patterns are interpreted as slots

• Short linear segments at specific angles are classified as chamfers

• Constant-curvature connectors between edges are recognized as fillets

  def build_dist_map(edge_img):
      inv = cv2.bitwise_not(edge_img)
      dist = cv2.distanceTransform(inv, cv2.DIST_L2, 3)
      return dist
  
  def support_score(dist_map, samples_xy, max_d=1.5):
      """
      samples_xy: (M,2) points sampled on fitted primitive
      return: ratio of samples close to real edges
      """
      h, w = dist_map.shape
      ok = 0
      total = 0
      for x, y in samples_xy:
          x, y = int(round(x)), int(round(y))
          if 0 <= x < w and 0 <= y < h:
              total += 1
              if dist_map[y, x] <= max_d:
                  ok += 1
      return ok / max(total, 1)
  
  

This rule-based geometric reasoning layer encodes engineering knowledge directly into the system, allowing it to interpret parts in ways that purely data-driven models cannot.

5. Dimensional Measurement

Once geometry is reconstructed, measurement becomes deterministic.

Because all features exist in calibrated coordinate space, the system can compute:

• Hole diameters and positions
• Center-to-center distances
• Slot widths and lengths
• Fillet radii
• Chamfer dimensions
• Outer boundary dimensions

def px_to_mm(x_px, scale_mm_per_px):
    return x_px * scale_mm_per_px

def measure_hole(circle, scale_mm_per_px):
    """
    circle: {cx, cy, r_px}
    """
    diameter_mm = px_to_mm(2 * circle["r_px"], scale_mm_per_px)
    return {"diameter_mm": diameter_mm, "center_px": (circle["cx"], circle["cy"])}

In controlled tests with consumer-grade industrial cameras, typical accuracy falls within ±0.02–0.10 mm, depending on feature size and image resolution—without telecentric lenses or specialized optics.

6. CAD Reconstruction and Output

The final output is a structured geometric representation:

• Lines
• Arcs
• Circles
• Feature metadata

This representation can be:

• Exported as DXF

• Compared directly against reference CAD

• Used for automated inspection or tolerance checks

• Visualized as an overlay for operator verification

  def to_geometry_objects(lines, arcs, circles):
      objs = []
      for ln in lines:
          objs.append({"type": "LINE", "p1": ln["p1"], "p2": ln["p2"]})
      for a in arcs:
          objs.append({"type": "ARC", "c": a["c"], "r": a["r"], "a0": a["a0"], "a1": a["a1"]})
      for c in circles:
          objs.append({"type": "CIRCLE", "c": (c["cx"], c["cy"]), "r": c["r_px"]})
      return objs
  
  

At this point, the image has effectively been converted into a measurable, machine-readable part description.

Why Not Use Deep Learning?

Deep learning excels at classification and segmentation, but inspection is fundamentally different:

• Precision matters more than recognition
• Subpixel accuracy is required
• Engineering constraints (tangency, curvature continuity) are rule-based
• Annotated datasets for manufacturing geometry are scarce

In practice, the most robust solution is a hybrid approach:

Classical computer vision + robust geometric fitting + rule-based reasoning, with AI used selectively rather than universally.

Why This Matters

Lowering the cost and complexity of precision inspection has real impact:

• Small manufacturers gain access to automated QC
• Measurement throughput increases
• Manual inspection errors decrease
• Engineering drawings and physical parts can be analyzed with the same pipeline

By replacing expensive hardware with intelligent geometry-driven vision, inspection becomes faster, cheaper, and more accessible.

What’s Next

Future extensions include:

• Multi-view reconstruction for 3D features
• Automated tolerance evaluation
• Integration with robotic handling
• AI-assisted interpretation of ambiguous geometry

But the core principle will remain the same:

Inspection is not about seeing objects. It is about understanding geometry.

Author Note

This system is part of an ongoing engineering effort and continues to evolve. The ideas presented here reflect practical lessons learned from real-world image-based measurement challenges.