ReLoop Inspector

ReLoop uses OpenCV 5 to detect smartphones, quality, reflections, pose, and defects across multiple views. An agent requests new shots; AWS stores state and proofs, with final human approval.

Comment

Inspiration

A cosmetic grade can determine whether a used smartphone is resold, repaired, discounted, or rejected. Yet this decision is often based on just a few images captured under inconsistent lighting conditions and viewing angles.

A reflection can resemble a scratch. A blurred frame can hide a crack. Two operators can interpret the same surface differently.

This led us to a more fundamental question:

Before asking a model to grade a device, how can we know whether it has seen enough reliable evidence?

ReLoop Inspector was inspired by the idea that computer vision should not remain passive. When the available image is inadequate, the responsible response is not a confident prediction — it is a request for a better view.

What it does

ReLoop Inspector is a human-in-the-loop Agentic Vision workflow for the cosmetic inspection of refurbished smartphones.

The operator places a supported device on a printed reference mat and captures a front view through a mobile-first interface.

OpenCV 5 evaluates:

  • device region and framing
  • focus
  • exposure
  • glare
  • pose
  • view coverage

If the evidence is insufficient, the system selects one corrective action — such as tilting the phone, stabilising the camera, changing the light, or capturing a closer view — and then verifies that the operator performed it correctly.

Accepted views are registered into a shared coordinate system. A physical scratch or crack should remain spatially stable across viewpoints, while a specular reflection generally changes with the camera and lighting conditions. ReLoop uses this difference as interpretable evidence.

Once the evidence passes the required quality and coverage rules, the system highlights possible defects and proposes a project-specific cosmetic grade.

The operator must then confirm, correct, or defer the result.

The final decision — together with the supporting evidence, model version, policy version, and any operator override — is recorded in an AWS-backed inspection certificate.

How we built it

We designed ReLoop Inspector as four connected layers.

1. Capture experience

A mobile-first web application guides the operator through a sequence of:

  1. front
  2. left-tilt
  3. right-tilt
  4. targeted rescan views, when required

An A4 reference mat with ArUco markers supports alignment, scale estimation, perspective correction, and pose verification.

2. OpenCV 5 perception

The vision pipeline performs:

  • device-region detection
  • perspective rectification
  • focus and exposure scoring
  • glare masking
  • pose estimation
  • view registration
  • candidate-defect processing
  • visual overlays

3. Evidence orchestration

An explicit state machine maintains the inspection state.

OpenCV outputs determine:

  • whether the workflow can continue
  • which view is missing
  • which corrective action should be requested
  • whether the newly captured frame actually improves the available evidence

4. AWS audit and reporting

The cloud layer manages the inspection session, consented evidence, state transitions, observability, and certificate generation through services such as API Gateway, Lambda or ECS, S3, DynamoDB, and CloudWatch.

The final implementation will list only the services actually deployed.

Evidence sufficiency

The evidence policy can be represented as a weighted sufficiency function:

$$ S = w_fF + w_eE + w_g(1-G) + w_pP + w_cC $$

where:

  • $$(F\) = focus quality $$
  • $$(E\) = exposure quality $$
  • $$(G\) = glare obstruction $$
  • $$(P\) = pose compliance $$
  • $$(C\) = required-view coverage $$

In practice, critical failures can act as hard gates: a high total score cannot compensate for a missing device region or an unverified requested pose.

The key technical proof is the closed loop:

Perception → Evidence decision → Requested action → Visual verification → Human approval

OpenCV is therefore not simply a preprocessing layer. Its runtime output actively changes the system's subsequent plan and action.

Challenges we faced

Separating real defects from image artefacts

Smartphone glass is highly reflective, and in a single frame glare can easily resemble physical damage.

We addressed this by designing a multi-view workflow and testing whether a candidate defect remains spatially stable after perspective registration.

Defining when evidence is sufficient

Focus, exposure, glare, pose, and coverage cannot be treated as unrelated scores. The system needs explicit rules for deciding when to accept a view, request another one, or defer the case.

We therefore made the evidence policy versioned, inspectable, and testable, rather than hiding it inside a generated explanation.

Avoiding false universality

Grades A, B, and C do not represent a single global standard.

ReLoop therefore uses a clearly labelled, project-specific grading policy, while keeping the operator responsible for the final outcome.

Evaluating honestly with limited physical devices

Different images of the same smartphone cannot be treated as independent test examples.

Our evaluation protocol therefore:

  • separates data at the device level
  • freezes thresholds before the held-out comparison
  • preserves human disagreement
  • reports device counts alongside frame counts

Protecting the core idea from feature expansion

Battery diagnostics, electrical testing, universal device coverage, and autonomous final grading are deliberately outside the MVP.

A narrow, reproducible Agentic Vision loop is more valuable than a broad but unreliable demonstration.

What we learned

We learned that the quality of a visual decision begins before inference. Improving image acquisition can be more valuable than forcing a more complex model to interpret inadequate evidence.

We also learned that useful autonomy does not require hiding the process. A deterministic state machine can still be agentic when perception changes the next action, the result is verified, and uncertainty is handled explicitly.

Most importantly, we learned that:

Human control is not a fallback.

In a workflow involving variable grading policies and limited prototype data, confirmation, override, and deferral are essential product features.

The goal is not to replace the grader. It is to make the evidence more consistent, explainable, and auditable.

What we are proud of

ReLoop Inspector connects a focused computer-vision contribution with a realistic operational workflow.

It combines:

Active evidence collection → Multi-view reasoning → Visible failure handling → Human approval → Cloud-backed audit trail

We are especially proud of the principle that shaped every design decision:

When vision is uncertain, ask for a better view.

What's next

Our next steps are to:

  • complete the OpenCV 5 implementation
  • deploy the final AWS architecture
  • run the frozen single-shot vs. agent-guided evaluation
  • conduct a small parallel pilot with a repair or refurbishment operator

The final submission will report measured benefits, time trade-offs, operator overrides, deferred cases, and representative failures.

We would rather show where the system remains uncertain than replace missing evidence with an unsupported performance claim.

Built With

Share this project:

Updates

Submission history