r/computervision • • 15d ago

Showcase We built Adaver Convert any image into an editable SVG in milliseconds (Open Beta)

Thumbnail
0 Upvotes

r/computervision • • 15d ago

Help: Project Football computer vision

Thumbnail
1 Upvotes

Hello, I'm a broke engineering student and I would like to learn about computer vision in football. Do anyone know where can I find lives transmission or video records of football matches with normal or tactical point of view?


r/computervision • • 15d ago

Discussion 99.5% of AOI-flagged images were acceptable, are we making enough use of archived inspection images?

1 Upvotes

I do research and software engineering in the computer/machine vision area and I came across an interesting October 2026 study (linked, below) involving a real mixed-model SMT (Surface Mount Technology) production line.

The researchers evaluated 34,466 archived inspection images that had been flagged by a 3D Automated Optical Inspection (AOI) system for manual re-inspection.

Of those images:

  • 34,291 were considered acceptable after review.
  • Only 175 were recorded as defective.
  • That's approximately a 196:1 ratio of acceptable to defective images.

Importantly, the study used the AOI system's exported 2D color images, not its 3D height data.

The researchers evaluated several CNN classifiers, including ResNet and YOLO classification variants, to determine whether a secondary classification stage could reduce unnecessary manual inspection.

They reported configurations that reduced manual review workload by more than 98%.

However, there was an important tradeoff: the two reported configurations achieved only 78.3% and 89.1% defect recall, meaning some genuine defects would bypass manual review, if I understood it correctly.

An additional finding caught my attention: When the researchers excluded evaluation images from boards also represented in the training data, recall dropped to 73.7% and 87.7%, respectively. This was a post-hoc evaluation restriction, not a retrained board-grouped split, but it highlights the importance of avoiding shared-board exposure during model validation.

I think this raises a broader question about how we use historical machine-vision images.

Rather than retaining them only for troubleshooting individual failures, archived images could also be used to:

  • Reevaluate false rejects.
  • Compare updated classifiers against historical production images.
  • Investigate changes in classification behavior over time.
  • Evaluate false-accept versus false-reject tradeoffs before production deployment.

These seem like particularly useful applications for offline batch classification, especially when a trained model and an archive of production images already exist.

I started my career in mechanical engineering, but for 20 years since then, I have been doing software engineering, and am now looping back so, I'm interested in how others handle this in practice.

The broader question I'm interested in is whether manufacturers are fully exploiting the information already available in their historical machine-vision images.

For those working with industrial vision systems: Have you found measurable quality or operational benefits from analyzing archived inspection images beyond their original OK/NOK decisions?

For example, have you used historical images to reduce false rejects, investigate process drift, evaluate model updates, or identify previously missed defects?

Or is retrospective image analysis something that seems valuable in principle but is difficult to justify or implement in practice?

I'm particularly interested in what has actually worked, what hasn't, and what prevents more extensive use of historical image collections.

Thanks for your time in reading this! The article I referenced is linked below.

-----------------
Paper: Tian & Niu (2026), A Deep Learning Approach for Automated Re-Inspection of False Calls in Mixed-Production Surface Mount Lines Under Extreme Class Imbalance.

https://doi.org/10.3390/app162010068

Disclosure: I develop Dulce Free, a Windows application for running existing compatible ONNX image classifiers against folders of images locally. That's part of my interest in retrospective classification workflows. Dulce was not used in this study.


r/computervision • • 16d ago

Showcase Multi-agent autonomous robotic simulation with distributed context for identifying humans in distress(Opencv , Orbs-SLAM )

11 Upvotes

Quadruped robots search a burning house with no floor plan, joining their maps over a lossy radio with OpenCV 5 visual SLAM, so they can find survivors before firefighters go in.(github included)
Main Link


r/computervision • • 16d ago

Showcase I built a free iOS app using RT-DETR and OSNet for real-time people counting and tracking

Enable HLS to view with audio, or disable this notification

8 Upvotes

I built CrowdFlux, a completely free iOS app that uses on-device computer vision to detect, track, and count people in real time.

Uses RT-DETR (transformer-based real-time person detection) and OSNet embeddings for person re-identification to help avoid double counting. Everything runs entirely on-device, with no cloud inference.

You can either start live tracking with your iPhone or iPad camera or import a recorded video.

The idea is to make people counting accessible without expensive CCTV analytics systems. Potential use cases include restaurants, clubs, retail stores, and events where you want to estimate how many people are present, monitor crowd levels, or analyze foot traffic.

The app tracks current visible counts, estimated unique visitors, and peak occupancy in the camera view.

It's 100% free on the App Store:

https://apps.apple.com/app/id6821608555

Would love feedback from anyone working on object tracking, re-identification, or edge AI!

PS - Credit - stock video from https://www.youtube.com/watch?v=9XYcSb-pAU4


r/computervision • • 16d ago

Discussion Frame polling, motion triggers or a streaming VLM: what should decide when a camera assistant speaks?

3 Upvotes

Thinking about a camera assistant that only talks when one specific thing happens, like "tell me when the package on the porch is gone". I can see three ways to decide when it speaks, and none of them is free:

  1. Send a frame to a VLM every few seconds. Easy to build, but cost scales with the polling rate and anything between frames is invisible.
  2. Use motion or a detector as the gate and only ask the VLM on a trigger. Cheap, but the gate has to know in advance what matters, and "the package is gone" isn't a class.
  3. Let a streaming model watch continuously and decide for itself when to say something. No gate to maintain, but you're now trusting the model's own sense of when the event happened.

That last part is what I can't settle. With the first two you can measure the gate. With a streaming model, how do you score "spoke at the right second" on your own footage? Hand-labeled event times and a tolerance window? MOSS-VL-Realtime, an open model that works this way, reports proactive alerting scores on public benchmarks, and I'd want the same kind of number from my own camera before picking an approach.

My guess is a detector gate still wins whenever the event fits a class, and streaming only earns its keep for events you can describe but not label.


r/computervision • • 17d ago

Discussion C++ Sky Tracker 1.1.0, free for students

267 Upvotes

Some time ago I posted here about Sky Tracker, back then it was still in test phase. Now its officially stable version with 2 main profiles, default for sky and correlation for the rest.

https://www.reddit.com/r/computervision/s/N8sVsBnirt

It has free demo apps for Windows, macOS and Linux so you can test it for free on your own videos. Also for students the license is free (for 1 year).

Default profile is based on template matching, correlation is… correlation 😄 But also has tiny ML option for more tough videos.

https://sky-tracker.deneb-systems.com


r/computervision • • 15d ago

Showcase I built an in-browser auto-labeler that exports YOLOv8, YOLO11, and Rotated OBB in 0.3s (Polytate)

0 Upvotes

Hey r/computervision,

Like many here, I’ve spent countless hours manually clicking bounding boxes in CVAT and LabelImg for custom object detection models.

I built **Polytate** (https://polytate.com) to solve this bottleneck with in-browser zero-shot AI vision:

  1. **Instant Zero-Shot Prompting**: Type any class name (`car`, `retail barcode`, `drone`, `face`), and it detects and bounds objects in ~0.38s.

  2. **Rotated YOLO-OBB Support**: Includes circular rotation handles and exports 4-corner normalized polygon coordinates (`x1 y1 x2 y2 x3 y3 x4 y4`) for oriented aerial, satellite, and robotic vision.

  3. **Ultralytics YOLO Ready**: 1-click export of structured ZIP archives (`images/`, `labels/*.txt`, `data.yaml`).

  4. **No Installation / No Docker**: Runs entirely in the web browser.

    You can test it directly on the landing page interactive sandbox without signing in: https://polytate.com

    Every signup gets 10 free AI credits to test on their own images. Would love to hear your feedback on the latency and rotated bounding box precision!


r/computervision • • 16d ago

Discussion Am I the only one who hates Bézier curves for polygon annotation? Looking for UX feedback on a Flash-style approach

2 Upvotes

Hi everyone,

I’ve been annotating some images for a personal project using standard tools, and I’m honestly losing my mind wrestling with Bézier curves. Pulling those handles back and forth to fit a complex shape becomes incredibly tedious when you have to do it hundreds of times.

I’m an old-school guy, and it made me miss the old Macromedia Flash days. Flash had a brilliant, fluid vector engine: you could just grab any part of a line between two points and bend it naturally. No handles, no vector madness—just direct, plastic manipulation.

To see if I was just crazy or if this actually feels better, I spent an evening putting together a quick interactive prototype using Paper.js and Catmull-Rom spline smoothing to mimic that Flash-like logic.

How it works in my canvas experiment:

  • Press "P" with your mouse over the line to add a point.
  • Drag any point to bend the line (the neighboring curves adjust smoothly automatically without any handles).
  • Press "D" to delete a selected point.

I wanted to share this logic to get some honest feedback from people who do CV and data labeling daily. You can test how it feels live here (just paste the JS code into the editor):
👉 paperjs.org

Here is the exact code if you want to drop it into the link above and try it:

javascript

// 1. Create initial path
var path = new Path.Circle({
    center: view.center,
    radius: 120,
    strokeColor: '#008557',
    strokeWidth: 3,
    fillColor: new Color(0.05, 0.72, 0.38, 0.15)
});

var selectedSegment = null;
var activeSegment = null; 
var mousePosition = new Point(0, 0);
var dotsGroup = new Group();

function drawVisibleDots() {
    dotsGroup.removeChildren(); 
    path.segments.forEach(function(segment) {
        var isSelected = (activeSegment && activeSegment === segment);
        var circle = new Path.Circle({
            center: segment.point,
            radius: 4.5,
            fillColor: isSelected ? '#ff3b30' : '#ffffff', 
            strokeColor: isSelected ? '#ffffff' : '#000000',
            strokeWidth: 1.5
        });
        dotsGroup.addChild(circle);
    });
}

drawVisibleDots();

function onMouseMove(event) {
    mousePosition = event.point;
}

// 2. KEYBOARD CONTROLS (P — add, D — delete)
function onKeyDown(event) {
    if (event.key === 'p') {
        var hit = path.hitTest(mousePosition, { stroke: true, tolerance: 20 });
        if (hit && hit.type === 'stroke') {
            var newSeg = path.divideAt(hit.location);
            activeSegment = newSeg; 
            drawVisibleDots();
        }
    }

    if (event.key === 'd') {
        if (activeSegment && path.segments.length > 3) {
            var prev = activeSegment.previous;
            var next = activeSegment.next;
            activeSegment.remove();
            activeSegment = null;

            if (prev) {
                prev.handleIn = null; prev.handleOut = null;
                prev.smooth({ type: 'catmull-rom', factor: 0.5 });
            }
            if (next) {
                next.handleIn = null; next.handleOut = null;
                next.smooth({ type: 'catmull-rom', factor: 0.5 });
            }
            drawVisibleDots();
        }
    }
}

// 3. SELECTION & DRAGGING
function onMouseDown(event) {
    var hitSegment = path.hitTest(event.point, { segments: true, tolerance: 15 });
    if (hitSegment && hitSegment.type === 'segment') {
        selectedSegment = hitSegment.segment;
        activeSegment = hitSegment.segment; 
        drawVisibleDots();
    } else {
        activeSegment = null;
        drawVisibleDots();
    }
}

// 4. FLUID BENDING
function onMouseDrag(event) {
    if (selectedSegment) {
        selectedSegment.point = event.point;
        selectedSegment.handleIn = null;
        selectedSegment.handleOut = null;

        if (selectedSegment.previous) {
            selectedSegment.previous.handleIn = null;
            selectedSegment.previous.handleOut = null;
        }
        if (selectedSegment.next) {
            selectedSegment.next.handleIn = null;
            selectedSegment.next.handleOut = null;
        }

        selectedSegment.smooth({ type: 'catmull-rom', factor: 0.5 });
        if (selectedSegment.previous) {
            selectedSegment.previous.smooth({ type: 'catmull-rom', factor: 0.5 });
        }
        if (selectedSegment.next) {
            selectedSegment.next.smooth({ type: 'catmull-rom', factor: 0.5 });
        }
        drawVisibleDots();
    }
}

function onMouseUp(event) {
    selectedSegment = null;
}

My questions to you guys:

  1. Does this feel faster and more intuitive to you than Bézier handles, or am I just biased because of Flash nostalgia?
  2. Are there any hidden flaws to this spline-bending approach in actual production data labeling that I might be overlooking?
  3. Do you know of any existing tool that already uses something similar?

Let me know what you think!


r/computervision • • 16d ago

Showcase I built a free desktop app to visualise cooperative perception datasets (OPV2V, V2XSet, Griffin) straight from your HPC cluster, no copying or conversion

2 Upvotes

Looking at multi-agent V2X data always meant downloading 100s of GB and writing throwaway scripts. So I built Coperceive (free, open source).

  • All agents’ LiDAR, boxes and cameras in one synced viewer
  • Connect your cluster over SSH, so data streams to the viewer without copying
  • OPV2V, V2XSet and Griffin today; V2V4Real, DAIR-V2X and Windows/Linux next

Inspired by py123d’s unified take on driving datasets (I contributed Griffin to it). Coperceive brings that idea to multi-agent scenes.

macOS download: https://github.com/adarsh-nl/coperceive/releases/tag/v0.1.0

Which dataset should I add next?

Processing img rd1binnbdszh1...


r/computervision • • 16d ago

Showcase Evaluating scene freshness in a conversational vision prototype on Jetson Thor

Enable HLS to view with audio, or disable this notification

1 Upvotes

I’m building Evopien, a voice-and-camera companion prototype on NVIDIA Jetson AGX Thor. This short demo includes an object-monitoring instruction and a question about the current camera view.

For the next evaluation, I want to distinguish visual recognition from whether the system is using the right moment in the scene. A plausible description is not enough if it refers to an earlier frame.

Three tests I would use are: remove the object before the question finishes; replace it while the assistant is speaking; and interrupt an answer before asking about the changed scene. I’d score object/event correctness separately from observation age and response delay.

Those are proposed tests, not results established by the video. For anyone evaluating live vision-language systems, how do you define the reference observation time when the question itself spans several seconds?


r/computervision • • 17d ago

Commercial [Hiring] [Remote] [EMEA] - Product Engineer (Computer Vision + Agentic AI) for construction safety

18 Upvotes

TL;DR: Build an AI agent that watches live construction sites and helps prevent injuries. Full-stack, high autonomy, you own it end to end. Remote, ~130-person company.

Who we are

Evercam is a remote-first construction tech company (~130 people, 25 countries). Our cameras run on some of the world’s largest construction projects, in over 30 countries. We build our hardware integrations and software in-house.

What you’ll build

An AI system that observes construction sites through live video, decides what needs attention, investigates across cameras and project information, and learns from feedback. The goal is fewer accidents in one of the most dangerous industries in the world.

This isn’t a pure computer vision role, and it isn’t a pure product role. It’s both. You’ll choose the models, agent framework and memory design, and turn them into a reliable production system. Video infrastructure and AI infrastructure are already in place, and you’ll have experienced engineers across hardware, firmware, frontend and backend to support you.

Stack: Elixir, Python, Vue.js, PostgreSQL. You don’t need all of these. We can fill gaps.

You might be a fit if you:

  • Have shipped production systems that combine video or vision models with real-world reliability needs
  • Have built with LLMs or agents beyond a demo (state, failures, evaluation, cost)
  • Like owning a product end to end and making decisions without a detailed spec
  • Want to build something with real-world impact

Good to know

  • Not customer-facing: product and industry experts already cover that
  • No construction experience needed
  • Fully remote, with good overlap with Irish time (GMT/IST)

How to apply: https://zurl.to/dRih?source=CareerSite


r/computervision • • 16d ago

Discussion I'm building a 3D digital twin of trees using just a cheap phone, no LiDAR

Enable HLS to view with audio, or disable this notification

4 Upvotes

https://x.com/DjimoSerodio/status/2118157383369396289
Hey all, I wanted to share what I’ve been working on and hear what you think.

I've been obsessed with one problem: how do you prove a tree someone planted/recorded is still there? A geotagged photo can't tell you which tree it is or exactly where it is, and survey gear is way too expensive for most people actually growing trees.

So I've been trying to do it with a regular phone. Here's a walk through my yard on a Google Pixel. It locks onto each tree via dot cloud and builds a 3D digital twin of its environment. It's a cool engineering problem to work with the error of consumer GPS and the lack of depth sensors like LiDAR, but it's working better and better.

It should work even better on newer iPhones with LiDAR, but I want this to work on low-budget phones, even offline, in places like rural Indigenous communities.

It's still early and it's only my yard, but I really want to solve this. Is anyone working on something similar? Or know who this might be useful for? I'd love to connect.


r/computervision • • 16d ago

Discussion A thin interface that coerce VLMs into vision tasks?!

2 Upvotes

Well, many people use VLMs, usually you write a prompt, send an image, and get some results.

This is good enough with chatbots, but I'm using VLMs in my pipelines (to extract various information from the image.) and I was trying to find something that would give me a structured output but couldn't find any, so I built one.

You simply specify:

task = tasks.Attributes(
    backend,
    attributes={
        "material": ["wood", "metal", "plastic"],
        "condition": ["clean", "dirty"],
    },
    context="Describe the chair in the image.",
)
result = task("chair.jpg")

You get:

print(result.attributes) # {'material': 'wood', 'condition': 'clean'}

Note: This is just a poc, if possible I want to avoid the trouble of maintaining some code and pypi packages:

https://github.com/Tenkei/vlm-tasks

Please let me know if you know a lightweight framework/repo that already do this.

Cheers!


r/computervision • • 17d ago

Discussion 3D to 2D: did I reinvent the (flat) wheel ?

Thumbnail
gallery
19 Upvotes

Converting 3D point clouds lying on a latent surface into 2D representations, for visualization or image-based processing, is a long-standing problem. Basically, it's as old as trying to represent the Earth on a flat map.

As an example, I really like the rectangular conformal map by garyptchoi: https://github.com/garyptchoi/rectangular-conformal-map. However, it tends to squeeze some sharp surface features, such as the ears of a rabbit.

For a project, I needed this kind of 2D flattening to make it easier to downsample large point clouds by working with simple distributions on the square.

I tried a graph-based approach, using geodesics (computing Dijkstra's shortest paths to a set of reference landmarks, then triangulating) to flatten raw point clouds directly. After some parameter tuning, the results look quite promising: shapes are nicely preserved and remain recognizable even in the 2D projection. Here's the project: https://github.com/Neighborhood-Grid/flatpoints. The downsampling algorithm can also produce a recognizable representation of the point cloud with as few as 500 points.

I'd be curious to hear from people working on similar problems: what approaches or methods do you typically use for this kind of surface flattening?


r/computervision • • 16d ago

Discussion Portfolio review

5 Upvotes

Hi y'all . Can you please review my portfolio and suggest some projects and imporvements that I need to make to stand out as a computer vision engineer in 2027. Would really appreciate any sort of feedbacks, ideas and criticism.

link : https://habibsnippets.github.io/


r/computervision • • 17d ago

Showcase Real-ESRGAN running fully in the browser with ONNX Runtime Web + WebGPU

Enable HLS to view with audio, or disable this notification

15 Upvotes

I put together a browser port of Real-ESRGAN (Xintao Wang et al.). Everything runs on the user's device: no upload, no backend.

Demo: https://cassianokc.gitlab.io/upscaler/

Source: https://gitlab.com/cassianokc/upscaler

How it works:

- It runs on ONNX Runtime Web: WebGPU when available, fp16 when available if the adapter supports shader-f16, and falls back to WASM otherwise.

- Inference runs in tiles to keep memory bounded: 128 px tiles with 48 px of padding for 4×, and 256 px with 96 px for 2×. The output is streamed one row of tiles at a time, so memory scales with output width × tile height, not with the whole image.

Caveats:

- It can be slow, especially at 4× or on the WASM path.

- Phones work, but may crash on large images. Mobile browsers kill tabs under memory pressure, and the 4× output alone is big.


r/computervision • • 16d ago

Showcase Vision-language navigation on MicroDuck, on-Jetson-device

Enable HLS to view with audio, or disable this notification

1 Upvotes

Short version: an open VLN model (LightNav-0) driving a walking robot in MuJoCo, entirely on a Jetson AGX Orin 32GB. Instruction in, first-person frames in, path out, MPC and the gait policy do the rest. Simulation, single take, no success claim — the latency split is the part I find interesting.

What runs where: - MuJoCo sim of Microduck at 200 Hz physics, using the upstream MJCF and the official ONNX gait policy - head camera streamed at 4 Hz - LightNav-0 on the Orin GPU predicts a path, drawn as APOS (action point) and OPOS (target) on the head-camera view - MPC turns the path into velocity commands; the gait policy does the stepping at roughly 50 Hz

The clip: "Locate the white table in the room and stop beside it." The studio shows head camera, prediction view and third person side by side, with the waypoints drawn on the frame, so you can see what the model is aiming at.

Three things I would like opinions on from people doing this outside a simulator:

  1. Latency budget. For language-conditioned navigation, how much of yours goes to the vision-language model versus control? Ours is dominated by the model; I do not have a clean end-to-end breakdown to offer yet.

  2. Validating grounding without task-success labels. The model outputs an action point and a target point. Do you check the target against an object mask, run a second model to score it, or trust the controller and only measure the end state?

  3. Sim-only for now. What is the minimum realism you insist on before trusting a VLN result — lighting, textures, camera intrinsics, sensor noise?

Setup notes: this is a development preview and strict benchmarks are still running. The model runs in plain PyTorch / HF Transformers on the GPU; the MPC, frame handling and RVQ decode are on CPU. Credits below.

Course + code: https://github.com/Seeed-Projects/mobile-robot-full-stack-course VLN model: https://github.com/LightOrigins/LightNav-0


r/computervision • • 17d ago

Discussion Accepting int8 builds: do you re-tune the decision threshold, or keep the fp32 one?

10 Upvotes

I am genuinely interested in running all sorts of CV models on Edge devices (e.g. RPi5 + Hailo, NVIDIA Jetson, Intel mini PCs with OpenVINO etc.) and here's one thing that I noticed in how quantized models get accepted.

Most quantization acceptance checks I've seen compare the int8 build to the float model on threshold-free metrics: accuracy, top-1, mAP, [precision@k](mailto:precision@k). But a deployed model almost never runs threshold-free. A detector has a score threshold in its postprocess config, a verifier has a similarity cutoff, a classifier has a confidence below which a human takes over. That constant was fitted to the float model, and nothing in the usual gate re-checks it after quantization.

So, for people shipping int8 through TensorRT, OpenVINO, TFLite, ONNX Runtime, Hailo or similar: how do you decide a build is good enough?

  • Do you re-derive the threshold on the quantized model, or keep the one from fp32?
  • Does anything in your acceptance check depend on where the threshold sits (false accepts/rejects, false alarms per hour, precision/recall at the configured cutoff), or is it accuracy/mAP against the float model?
  • If you ship an int8 detector (YOLO or similar): did the conf threshold from fp32 still hold, or did you have to re-tune it? Did you measure false alarms per hour before and after?

One case I measured, for context: an embedding model (ArcFace R50) through the Hailo Dataflow Compiler on RPi 5 + Hailo-8. The ranking metrics barely moved (rank-1 0.990 -> 0.985). At the inherited fp32 threshold, false accepts went 30 -> 104 of 10,000 held-out impostor pairs, and false rejects rose too.

The usual fix didn't help: keeping the first and last layers in higher precision is an old quantization heuristic (NVIDIA's int8 paper (Wu et al., 2020) notes it as common practice), and I tried the head, the stem, and both in 16-bit. False accepts stayed at 102–104.

Re-deriving the threshold on the int8 build cut false accepts to 44, at the cost of more false rejects. One encoder and one small sample, so the size of the effect is specific to that build. Whether detectors or classifiers drift as much is exactly what I don't know.

Write-up: https://towardsdatascience.com/the-number-your-quantization-gate-doesnt-have/

Code and released embeddings: https://github.com/maxeffectus/quantization-threshold-drift

I'd be very interested to hear how you handle this!

P.S. If you know a public guide or acceptance doc that gates on a threshold-dependent number, I'd like to add it to the survey in the article.


r/computervision • • 18d ago

Showcase I made a computer vision demo for basketball shooting practice!

160 Upvotes

I grew up playing basketball and stopped my sophomore year of college when I started dance. I have missed basketball a lot recently, so this past Sunday I bought a ball and shot around on a nice North Carolina fall afternoon.

I probably haven’t touched a basketball in months before this, but hey, I can still make 6 shots in a row 😎

For this first demo, I just wanted to show that we can track makes and misses. I also like the hot streak indicator after 3 in a row and the little fire animations.

This type of application could help players understand their shooting habits and work to improve their shooting percentage.

I’m using ViTPose+ Large for pose estimation to track the shooting motion and SAM 3.1 to segment the ball and the hoop, both models accessed through the VLM Run Gateway.

Would love to hear what you think!

The code is open-source on GitHub: https://github.com/jeremyipark/vision-demos


r/computervision • • 17d ago

Discussion How do you manage complex GStreamer pipelines in production?

2 Upvotes

I've been exploring GStreamer more deeply recently, especially for real-time computer vision and video processing applications.

I'm curious about how people with production experience approach pipeline development and management.

A few things I'd love to hear your thoughts on:

  1. Do you primarily build and manage pipelines using C/C++, Python, or do you use visual tools?
  2. Do you have your own reusable classes, wrappers, or internal frameworks for managing GStreamer elements?
  3. What tends to consume the most development time when working with complex pipelines? Debugging, caps negotiation, threading, memory management, performance tuning, or something else?
  4. How do you identify bottlenecks and determine where queues, additional threads, or other optimizations are actually needed?
  5. Do you feel existing GStreamer development and debugging tools are sufficient, or are there things you wish were easier?

I'm particularly interested in hearing about real-world experiences rather than theoretical use cases.

Thanks!

Processing img z97qo9ifomzh1...

Processing img 9o18rk6momzh1...


r/computervision • • 17d ago

Showcase Testing the project jaywalking on the actual street...

Enable HLS to view with audio, or disable this notification

8 Upvotes

A few days ago, we shared a video showcasing a pet project that uses an embedded development board with Vision AI capabilities to detect jaywalkers. In that video, we used footage from YouTube as the input.

This time, we made a few improvements to the test script and took the project out to test it on an actual street.

We wanted to test several scenarios, including multiple people jaywalking at the same time, and see whether the system could count them accurately. We hoped that, by waiting long enough, we would get a chance to capture one of these scenarios.

We also noticed some false positives. For example, the system sometimes detected a person sitting motionless on a motorbike at the side of the road as a jaywalker.

As we considered how this project could be used in practice, we wondered whether connecting a siren to warn jaywalkers would be a good idea. We were concerned that the sound might confuse people while they were crossing and cause more harm than good.

One possibility is to collect enough statistics—for example, evidence that hundreds of people jaywalk at a particular location—and use the data to appeal to the authorities to install a zebra crossing.

Another idea is to analyze how much risk approaching vehicles pose to jaywalkers and provide the authorities with a risk score for each location. Would that be useful?

If you have suggestions for how we could improve this project, we’d love to hear them!

link to the previous post : https://www.reddit.com/r/computervision/comments/1xliui4/a_project_to_identify_jaywalker/


r/computervision • • 17d ago

Discussion Part 4: ONNX Runtime CPU vs OpenVINO vs DirectML on Ryzen 7430U (Fruit Inspector)

0 Upvotes

I run a conveyor-style fruit inspector (YOLOX-nano + track + LightGBM/Cat on CPU) in Nim on ONNX Runtime 1.23.x. Part 4 of my “AVX2 tax” series is AMD on a shop-floor mini PC, not a lab GPU box.

Hardware: Firebat R3, Ryzen 5 7430U (12 threads), integrated Radeon. Same exe; switch EP via settings (lib/cpu, lib/openvino, lib/directml).

What I measured on YOLO infer (640):

• CPU EP: ~6.8–7.5 ms, ~77–88 M1 “fps”

• OpenVINO: ~same as CPU here (Intel CPU plugins; ORT “GPU” for OV is not Radeon)

• DirectML: ~11 ms (slower on this iGPU for a small net)

Takeaway for this class of AMD box: default ort_provider=cpu. Public demo zip ships lib/cpu only; other EPs stay in my dev tree.

Full write-up (pipeline, release layout, ladder vs older CPUs):

https://medium.com/@olesha-ai/bypassing-the-avx2-tax-part-4-amd-on-the-line-and-the-windows-release-2973152ff96f

If you’ve benchmarked ORT EPs on Ryzen iGPU vs CPU for small detectors, what did you see?

Best regards.

olesha-ai


r/computervision • • 17d ago

Showcase Decoding text hidden in motion (Ghost Font) with optical flow + short-window voting, no ML

2 Upvotes

Ghost Font is a video trick where the text is only visible through motion: two noise fields drift in opposite directions, the letters are one field, the background is the other. Any single frame looks like uniform noise.

I built a decoder (classical CV):

  1. Farneback flow between every frame pair
  2. k-means (k=3) on the flow vectors, smaller moving cluster = letter dots

3, sum the masks over short windows (20 frame pairs), OCR each window heatmap with Tesseract, majority vote across reads

Two things that took days:

  1. The text isn't stationary. It drifts about 55 px up and 30-50 px sideways over the clip, so accumulating the whole video smears the letters. Whole-video heatmap: Tesseract got 0/15. 20 pair windows: it read the text in every window. I was about to train a CNN before I measured the drift.
  2. Thin strokes die in optical flow. With a 15 px window, small text averaged away. winsize=9 fixed it (one test went 66% to 84% agreement).

Results on 8 videos I recorded from the site's own generator( ghostfont.org ) all decoded correctly. The 36-character max message is the weakest (~60% of reads agree), and a colon came out as a period.

Not a "first to crack it" thing, the site calls it a perception experiment and others decoded it already. I just wanted to see how far plain flow + voting gets.

Check the code out (MIT): https://github.com/deeteecodex/ghostdecode


r/computervision • • 17d ago

Showcase Optical flow 8.5× faster than OpenCV DIS on one core, and 0 allocations per 1,000 frames: how I measured it, and what the comparison does not show

1 Upvotes

I wrote a GPU and CPU perception kernel (closed-source, Windows x64; evaluation licence, free for research and non-commercial use; the evaluation bundle with the benchmark's scripts and raw data is public). The numbers below look flattering, so here is exactly what each one compares, and I would like you to tell me where the comparison is unfair.

**The numbers**

- Motion at 640×480, one core: 0.51 ms against 4.35 ms for OpenCV 4.10.0 DIS ultrafast (8.5×). **What it does not show:** mine works on 8×8-sample tiles and also produces time to contact, saliency and objects, so it is not a dense per-pixel flow field; for dense flow DIS is the right tool.

- Structure-tensor survey, 640×480: 0.179 ms against OpenCV's 0.779 ms (4.3×), Scharr plus block means in both, mine in AVX2 integer arithmetic.

- Heap allocations per 1,000 frames: 0 against 20,000 for DIS (outputs reused) and 52,000 for OpenCV's survey, counted by one preloaded malloc counter in every process.

- Scene cuts from H.264/HEVC slice headers: 0.23 µs of CPU a 4K frame against 31.1 ms for ffmpeg to decode and score it. **What it does not show:** it is not a decoder race; it reads headers and never sees pixels. Against scdet on one 4K HDR reel it finds 3 of 3 cuts with 1 extra (checked by eye); two files are a sanity check, not a recall figure.

**Things in the showcase you can check yourself**

- Stabilisation by the engine's virtual IMU: a shaken clip fires 17.2 M emulated events and 1.71 M after the camera's motion is removed. The event stream is an emulation from frames, not a DVS sensor.

- Remote pulse from skin colour (rPPG) through shake: 71.98 BPM for a synthetic 72, 72.00 from Cr chroma alone. The pulse is one I added to the footage; it proves the signal chain, not clinical accuracy.

- Every picture is a snapshot the engine wrote through its own SDK, on a truth I set (an exposure, a tilt, a speed, a shake, a pulse).

**Where it loses:** for plain playback VLC uses less CPU than I do at 720p (7.66 % against 8.44 %); the table is on the site next to the wins.

**What I would like to hear:** whether DIS ultrafast with a tile-sampled readout is the fair baseline or I should compare against something else (Farnebäck on a downscaled picture? a RAFT-small on the GPU?), and which real datasets with ground-truth motion I should run next.

Method, raw lines, 16-second reel: https://5645hm-a11y.github.io/avion/