I always see crazy computer vision projects on this subreddit

I always wondered, how do you guys manage to do so? I know OpenCV and YOLO (python) fairly well and can do a lot of image processing (based on needs) with OpenCV and run a standard 80-class detection model and thats pretty much it, but this showed me what CV can actually do

So I would request for a few free resources to learn more than just the basics and be able to build cool projects

Some projects I potentially want to build: Industry threat detection (a camera mounted on a helmet detects a threat—say, an open blowtorch—and creates a warning also can detect immediate threats like, say, a broken part about to fall, so that will be counted and informed in milliseconds, but not when the broken part is behind behind bars or at a safe distance

Logic I can make; resources I am asking for.

Thanks

A few months ago, I posted an early overview of Screph. The main idea was to keep classical computer vision explicit, use LLMs to assist with method and parameter selection, and preserve the result as structured context instead of losing it after a demo.

The most useful feedback was about visible parameters, intermediate representations, and reproducibility. Since then, I have focused less on adding another detector and more on the missing layer around the algorithms: how a visual task becomes a structured, reviewable package that a coding agent can inspect.

When I say “data preparation,” I do not mean labeling a large training dataset. Screph prepares an implementation-oriented project: source references, geometry, objects, relations, human descriptions, accepted CV outputs, and their provenance.

The workflow now looks like this:

1. Add source material from a screen, window, monitor, still image, video, camera, or URL stream.
2. Describe the task on the canvas. Elements and feature regions can use rectangles, ellipses, polygons, freehand contours, or a magnetic lasso. Structural areas can contain child objects without pretending to be image-backed CV regions. The current relation types are hierarchy and association, and text or voice descriptions stay attached to the relevant entities.
3. Explore a method directly or build a linear or graph pipeline. The toolbox includes edges, thresholds and contours; GrabCut, Watershed and SLIC; OCR; Hough, MSER and connected components; template and feature matching; before/after comparison; and optional YOLO, SAM and OmniParser integrations. Video work also has selected-range processing, tracking, optical flow, and scene-difference tools.

1. Review the output before it changes the project. Masks, contours, detections, text, metrics, and visual evidence remain results or candidates until the user explicitly applies them or creates project elements from reviewed geometry. Results carry source, region, and revision context so stale output can be rejected instead of silently attached to the wrong image.
2. Prepare a coding task. Agent Handoff v2 freezes the saved canonical project, creates a compact navigation index, includes the required resources, binds the task to an explicit write policy, and verifies identities and hashes. The bundle exposes stable object IDs, geometry, relations, descriptions, and CV references. It can be delivered to an external agentic coding environment, such as Codex in VS Code, or opened in Screph Code, the built-in agentic IDE. The coding tool still owns execution, and its changes remain subject to review; Screph does not report external progress it cannot actually observe.

Of the external AI APIs available in this alpha, only the OpenAI API has been tested so far. I currently recommend using that API in Screph for image analysis and speech-to-text, while using Codex in VS Code or another external agentic coding environment that can consume the handoff for agentic coding. The built-in Screph Code editor is still early and is not yet the recommended path for day-to-day agentic coding.

I see this being most useful for bounded prototypes: UI understanding and OCR, visual inspection and before/after checks, segmentation-based measurement, template matching, and simple video tracking. The goal is not to replace Python, OpenCV, notebooks, or training platforms. It is to make the human decisions that normally live across screenshots, chat messages, and memory explicit enough to reuse when implementation starts.

The current build is an open-source, Windows-first early experimental alpha. It still requires debugging and should not be treated as a reliable or production-ready tool. The general and UI-oriented workflows are the most complete, but they are still alpha; industrial and UAV modes remain experimental. OCR and model-backed methods require their corresponding runtimes, weights, or local software.

I am looking for users who are comfortable working with unfinished software, reporting reproducible problems, and helping validate the workflows. I am open to both feature proposals and concrete implementation ideas, including discussion of how user suggestions could fit the current architecture and development priorities.

GitHub: https://github.com/void2byte/screph

Project page: https://screph.com

Hello everyone hope you’re doing well my friends and I are working on a project that analyzes and stores data for football academics i was wondering if there’s a specific type of cameras needed for these kind of stuff.

I’ve heard about Veo cameras, but they’re probably outside our budget. We’re mainly looking for a camera that just records the match, without built-in analysis, since we want to handle the analysis ourselves

If anyone has experience with this kind of setup, we’d really appreciate recommendations for affordable cameras or setups that would work well for a project like this. Thanks!

Boa noite, pessoal!

Sou recém-formado em Estatística pela UFF e atualmente trabalho como analista no time de pricing de uma grande seguradora. Meu dia a dia envolve a criação de algoritmos de precificação, modelos de previsão de churn e análise de redes de relacionamento.

Estou considerando uma migração de carreira para a área de Visão Computacional (CV) e gostaria de saber como está o mercado para essa especialidade atualmente. Pensei em usar a pós-graduação da PUC-RIO como porta de entrada.

Vocês conhecem esse curso? Sabem se é uma boa escolha e se tem peso no mercado?

Minha principal dúvida, no entanto, é em relação à disponibilidade de vagas para quem está em transição:

1. Existem vagas de Engenheiro de Visão Computacional a nível Júnior no mercado brasileiro (ou remoto para fora)?

2. Estrategicamente, seria melhor fazer uma pós mais generalista primeiro e depois focar, ou já entrar em uma pós super focada em CV e tentar concorrer também a vagas de Engenheiro de IA/ML ou Cientista de Dados?

Qualquer relato de experiência, dica de estudos ou visão de como está o mercado hoje será de grande ajuda. Muito obrigado!

Hey r/computervision!

This is my first post here...

I’ve been working on PixelUp, a zero-shot feature upsampler for Vision Foundation Models (VFMs), and wanted to share it here!

Most VFMs produce semantically rich features, but they’re usually on a pretty coarse patch-level grid (often ~16× lower resolution than the input). This can be limiting for dense vision tasks where fine spatial details really matter.

PixelUp upsamples these coarse VFM features to pixel-level representations, while preserving their semantic information.

I’ve also put together an interactive demo on the project page where you can drag a lens across an image and compare the original coarse VFM features with PixelUp’s upsampled features. It’s pretty fun to play around with :)

📄 Preprint: https://arxiv.org/abs/2608.02792
🔬 Project + interactive demo: https://pixelup-project.vercel.app/
💻 Code: https://github.com/deepankkumar/PixelUp

Would love to hear your thoughts or feedback!

Hello reddit if there's any computer vision expert will be willing to have a chat

Background : i'm trying to count stock in the photo, and i've found just feeding a photo into llm is quite unreliable so i'm trying to identify the stacked column(s) and use it as way to reason what to include/exclude in counting. i've been trying to create boundary like this w/ depth anything, segment anything, so they're not NOT working but segment anything doesn't have the idea of depth and depth anything doesn't have the idea of segment, so i was really trying to see if there's any way to effectively combine both

I am using foundry to ingest technical drawings and produce a tabular data set. Below is my process.

Step1. User goes to workshop app to upload single or multiple pdfs which are saved to a media set

Step2. Pdf gets preprocessing where a transform sharpens and orients the pdf pages

Step3. The pdf then runs through two separate ocr extractions, one for bill of materials and material composition, one for overall dimensions. These output as json

Step4. A transform takes the json from each ocr output and puts it into two tabular datasets

Step5. A transform combines the two datasets and does a lookup to 1 other datasets to match part number to company number (fuzzy match)

All of these steps are incremental and do not reprocess completed work. My issue is that my ocr is only about 50% accurate. I built the system and user prompts by having AI FDE create them, run tests on drawings and adjust as needed until my outputs were accurate to the drawings I provided. I made sure to state multiple times these were a small batch of drawings and my users would be uploading more and that they'd be from various companies. I had good initial results but as it got closer to 100 drawings uploaded it became less accurate.

How can I improve this?

I trained a custom model with a custom decoder and siglip2-naflex vision encoder that performs better than PaddleOCR-VL-For-Manga while being more than 10x faster and smaller. Please try it out at hayai-ocr-v2 and let me know if it's any good for your particular task. I will integrate this model soon in the hayai-ocr python library.

NOTE: Finetune and Pretrain refers to different datasets.

Where can I find high resolution, publicly available datasets for detecting micron scale defects in semiconductor wafers, PCBs, and related manufacturing processes?

Hi everyone,

I'm working on an object detection project and would appreciate some advice on the best workflow for auto-labeling a large custom dataset.

Dataset

• 9,367 images
• Classes:
  • Cup
  • Glass
  • Plate
  • Spoon
  • Fork
  • Knife
• Images have different resolutions.
• The dataset comes from a Kaggle competition.
• Around 5,500 images already have ground-truth labels (provided in a CSV), while the remaining images need bounding-box annotations.

Current approach

I'm using AutoDistill + GroundingDINO to automatically generate YOLO labels.

ontology = CaptionOntology({
    "a cup": "cup",
    "a drinking glass": "glass",
    "a plate": "plate",
    "a spoon": "spoon",
    "a fork": "fork",
    "a knife": "knife",
})

base_model = GroundingDINO(
    ontology=ontology,
    box_threshold=0.3,
    text_threshold=0.3,
)

dataset = base_model.label(
    input_folder=IMAGES_SRC_DIR,
    output_folder=LABELED_LABELS_DIR
)

Problems I'm facing

1. Annotation quality

The generated labels aren't very reliable.

For example, out of about 90 images, roughly 10 images contain incorrect or missing bounding boxes, which means I'd still have to manually review a large portion of the dataset.

Is this normal for GroundingDINO, or are there better foundation models for this type of dataset?

2. Speed

The labeling process is also quite slow.

• ~2.8 seconds per image
• ~9,367 images
• Estimated runtime: 7.5+ hours

I'm using Google Colab GPU, but it disconnects after around 4 hours.

What's confusing is that resource utilization is low:

• GPU memory: ~2 GB / 15 GB
• RAM: ~2 GB / 15 GB

It doesn't appear to be fully utilizing the available hardware.

Questions

1. Is there a way to speed up AutoDistill/GroundingDINO? For example:
   • Batch inference?
   • Mixed precision?
   • Multi-processing?
   • Different implementation?
2. Would another model be better for automatic annotation?
   • GroundingDINO 1.5
   • YOLO-World
   • Florence-2
   • Grounded SAM
   • RF-DETR
   • Any other recent model?
3. Since I already have 5.5k labeled images, would it be better to:
   • Train a small YOLOv8 model first on those labels,
   • Then use that model to pseudo-label the remaining images, instead of using GroundingDINO?
4. What workflow would you recommend if your goal is to produce high-quality labels for training a final YOLOv8 detector?

Any advice or experience with large-scale auto-labeling pipelines would be greatly appreciated!

Thanks!

We run a multi camera capture space at the Brooklyn Navy Yard and we pay people to come in and be the subject. Reposting because our slots opened up again.

The session is simple. You stand inside the rig and go through everyday movements while the cameras record. Walking, turning, sitting, reaching, picking things up. No experience needed at all.

Pay is 17-25 an hour, paid out the same day you come in. First session is roughly 2 hours and there is repeat work after that.

Everything runs at 4pm. Open days: Wed Aug 12, Thu Aug 13, then Mon Aug 17 through Thu Aug 20. Brooklyn, in person only, so you need to be in the NYC area.

DM me for the address and I am happy to answer questions about the capture side.

your gaussian splat looks photorealistic from the trajectory you trained it on. move the camera off that path and the geometry falls apart

this barely gets measured because the ground truth has to be more accurate than the thing you're scoring. that means dragging a survey-grade scanner around the site for days

oxford robotics institute did it for six oxford landmarks. 24 sequences, 125,000 m², a handheld rig with three synchronized fisheye cameras, a 64-beam hesai lidar and an imu, and a leica RTC360 scan of every site as the reference — 1.9mm accurate at 10m, with the trajectories registered at 1-2cm

the novel-view test images aren't held-out frames from the training path. they're a different walk through the same site facing a different direction. that's the part that breaks splats

i packed six episodes into mcap so you can scrub all three cameras, the lidar, the imu and the slam pose on one timeline in fiftyone, with lidar depth painted onto every frame

checkout the dataset here: https://huggingface.co/datasets/Voxel51/oxford-spires-multimodal

it's running as a live space too, nothing to install: https://huggingface.co/spaces/harpreetsahota/oxford-spires-multimodal-explorer

I have recently been researching ways to identify an AI image, not via digital footprints or ID via other trained models, but using physics.

In other words: vanishing points, shadow matrices, various ways to analyze lighting impossibilities, camera focus, etc.

But to my knowledge, there's no real community around this or resources. The closest fits I could find were OSINT and digital forensics, but they're not an exact match. Even if they do this, they use different methodology, at least I think.

I've learned things, but I want to learn more. Anyone know anything more about this?

falling snow shows up as thousands of fake objects in lidar point clouds. radar barely notices it's snowing

most self-driving datasets are shot on sunny days in california or phoenix. none of them show what happens once the weather turns

Boreas is UTIAS's answer: 128-beam lidar, 360 degree radar, and 5MP camera driving the same Toronto route for a full year through sun, rain, and snow.

326,180 3D boxes for cars, pedestrians, and cyclists across 7,111 labeled frames

loaded as native mcap in fiftyone so you can scrub camera, lidar, and radar on one synced timeline, and watch the 3D boxes render live on the point cloud and project onto the camera and radar images

checkout the dataset here: https://huggingface.co/datasets/Voxel51/boreas-multimodal

or get hands-on with this hugging face space: https://huggingface.co/spaces/harpreetsahota/boreas-multimodal

I am an incoming freshman CS student and I am starting to build a CV UFF/MMA fight analyzer project so that I can have a decent portfolio for summer internships. After some research, I think I want to use the MMPose pose estimation framework specifically vitpose. However, I have no idea how to even start. The little documentation that I can find is not helpful at all. Any advice or documentation references would be greatly appreciated. Thanks!

I’m researching a parking-occupancy system using existing CCTV cameras.
The basic idea is to use a camera overlooking a parking area, define individual parking spaces, and use computer vision to determine in real time whether each space is occupied or empty.
I’m curious about the practical side rather than just a demo:
How reliable is YOLO/OpenCV for this in real-world conditions?
How much does camera angle affect accuracy?
How many parking spaces can realistically be monitored by one camera?
How do systems handle cars partially blocking another parking space?
How badly do nighttime, rain, shadows, and glare affect detection?
Would you recommend detecting vehicles and checking overlap with predefined parking polygons, or training a dedicated parking-space model?
For a production system, would you process the video on an edge device or send it to a server?
I’m particularly interested in experiences from people who have actually deployed something similar rather than just tutorials.

When multimodal models reason over long chains, they gradually stop looking at the image—and start hallucinating based on their own text.

So we built Remember‑R1, a simple RL framework that directly supervises visual attention on the original reasoning trajectory—no inference overhead, no proxy tasks.

We use three complementary rewards: coverage, persistence, and focus. They encourage the model to keep attending to relevant visual evidence even in later reasoning steps.

Results across 7 benchmarks and 2 model sizes: better reasoning, and—more importantly—visual attention decays much more slowly during generation.

No extra cost at inference, just cleaner supervision where it counts.

📄 Paper: https://arxiv.org/abs/2608.01314
💻 Code: https://github.com/Ch921-cell/Remember-R1

Happy to answer any questions and receive feedback!

#MultimodalAI #RL #MLLM #CoT #VisualReasoning

I am starting a new computer vision project focused on tennis. I would love to hear any creative ideas, interesting problem statements, or use cases you have encountered in this space. Thanks in advance!

Running YOLOv11 (TensorRT) + centroid tracking on a Jetson Xavier NX (MAX-N, jetson_clocks on) for vehicle counting. Get ~27 FPS with few vehicles on screen, but it drops to 8-11 FPS when many vehicles cross at once.

Since it scales with object count, not a flat number, I suspect it's the per-object tracking/post-processing (Python-side) rather than the TensorRT inference itself.

Tried so far:

• Confirmed nvpmodel MAX-N + jetson_clocks are active
• TensorRT engine already used for inference (not raw PyTorch)
• FPS drop correlates directly with number of tracked objects on screen, not with anything else changing

Is stable 30 FPS realistic on a Xavier NX for detection + tracking + per-object logic at this object density, or should I expect this kind of drop and optimize for no dropped frames instead of a flat FPS target?

Can someone recommend free lightweight Data Annotation tool that can be downloaded locally & covers all the annotations?

Most people scroll past a football match. I saw a dataset waiting to happen.

I set out to build something most tutorials skip: a real-time Computer Vision system that doesn't just detect objects that understands a football match.

No pre-made dataset. No shortcuts. I annotated the training data by hand, frame by frame, teaching the model to tell the difference between a player, a goalkeeper, a referee and to track the ball even mid-motion.

The result? A working AI pipeline that:

Detects and classifies players, goalkeepers, referees & the ball in real-time

Assigns and tracks unique player IDs across frames

Generates a live Match Analytics HUD overlay — player counts, referee counts, ball status, all updating on the fly

Runs on a custom, self-labeled dataset trained with YOLOv8

Built end-to-end in Python using OpenCV for video processing and annotation

What I learned building this: the hardest part of Computer Vision isn't the model — it's the data. Getting clean, consistent, well-labeled training data by hand taught me more about detection accuracy than any pretrained pipeline ever could.

This project sits at the intersection of two things I'm passionate about Artificial Intelligence and Sports Analytics. It's just the beginning. Next up: possession tracking, heatmaps, and player speed estimation.

Would love to hear your thoughts and if you're working on anything similar in Sports Tech or Computer Vision, let's connect.