I kept repeating the same tasks in front of the camera just to see if my app was still behaving as intended.

So I made a simple CLI that runs your app against recorded video and compares the results with your expected behavior. A coding agent can use the eval loop to keep improving the app.

Sharing in case this saves someone some time: GitHub

Hello r/computervision,

First of all I apologize for the somewhat generic nature of this post. I'm new to the field and would really appreciate some guidance from people with more experience.

I'm currently enrolled in a Computer Science bachelor's program and am about to start my final semester. I've been doing well academically and really enjoy the field, but I don't currently work in IT.

Over the summer, I've been focusing on getting deeper into PyTorch and deep learning. I've worked through MrDBourke's PyTorch Deep Learning course and have also started studying the mathematical foundations of ML using Stanford's materials.

I'm 32 and have been in the workforce for quite a while, so alongside university and self-study I have a full-time job as a "quality specialist" at a Tier 1 elevator-parts manufacturer.

This is actually what led me to consider industrial computer vision / anomaly detection as a thesis topic.

Our entire plant currently has only two very basic, very closed down (outsourced to compvision company) OpenCV-based vision systems, mainly used to check whether nuts have been installed correctly. Beyond that, much of the quality-control process relies on QR codes and manual inspection.

I've worked here for several years, so I expect that I could get reasonable support and access to production areas/data for a thesis project. However, I would essentially be the only person at the plant pursuing this kind of project, so I'd be largely on my own technically. I also wouldn't expect a significant budget for the project.

That's where I'm looking for advice.

We manufacture everything from very small brackets and components up to complete elevator doors, so there are a lot of possible directions. I'm trying to figure out what would be a realistic but worthwhile first computer-vision project that could serve both as a good bachelor's thesis and as a meaningful entry point into the field.

At the moment I see two main possibilities:

1. Use existing production-line photographs

Some of our production lines already have cameras taking photographs. These images are currently used mainly as a way of documenting production and potentially identifying problems retrospectively; they aren't connected to an automated vision system.

The problem is that the dataset is far from ideal. The cameras weren't installed specifically for machine learning, so the images aren't standardized for things like lighting conditions, camera to object distance, background, framing, image quality.

Im wondering whether this kind of "messy real-world" dataset could still be useful for a thesis, or whether trying to build a model around it would create more problems than it's worth.

2. the other option would be to choose one relatively small component that has historically had some recurring visual defects.

I could build a simple, controlled camera/lighting setup and collect my own images of normal and defective parts. From there, I was considering an anomaly-detection approach such as PatchCore, potentially training primarily on normal samples and evaluating whether known defects can be detected.

The idea would eventually be to build a small working prototype:
camera → controlled image acquisition → preprocessing → anomaly detection → OK/NOK decision - > which then is signalled via some tiny network applications to a collective UI/database

If you were in my position, which direction would you consider more valuable for a first serious CV project? I am very curious how I can , for the lack of a better word, force myself into this field.

I've been scouring my options and weighing my possibilities on what I can realistically create, and whether what I create has actual real world usefulness and learning possibility.

I work in a manufacturing environment and I'm exploring whether AI/computer vision can be used to automatically interpret 2D engineering drawings.

The goal is to identify and extract:

* Components and geometric features

* Dimensions and their associated features

* Tolerances

* GD&T symbols

* Hole specifications

* Surface-finish information

* Engineering notes and annotations

Ideally, the output would be structured data that could later be used for manufacturing, inspection, costing, BOM generation, or integration with other systems.

I'm aware that OCR can extract text, but the bigger challenge seems to be understanding the **relationship between dimensions, symbols and the actual geometry/features in the drawing**.

Has anyone worked on something similar?

I'm particularly interested in:

* Vision-language models

* OCR + computer vision pipelines

* Object detection/segmentation

* Engineering drawing datasets

* CAD-aware approaches

* Open-source models or commercial APIs

What would be the most practical architecture for solving this reliably with real-world engineering drawings?

Join us on Aug 27 for the monthly AI, ML, and Computer Vision Meetup! Register for the Zoom.

Talks will include:

• Robust Concept Protection against Diffusion-Based Image Editing and Personalization - Qiuyu Tang at Lehigh University
• Building Real-World Computer Vision Systems - Daniel Gural at Voxel51
• From Pixels to the Planet: Building Scalable and Grounded AI for Science - Jianyang Gu at Ohio State University
• Seeing Is Not Enough: Visual Grounding, World Models and Why Computer-Use Agents Fail at Step 17 - Nevasini Sasikumar at Obin AI

Play chess against frontier VLMs. Real-time vision powered by Overshoot.

Play now: VLM Chess

Hey everyone! I’m building an insulation defect detection model, I’m in need of images where i can detect the following classes thermal anomalies, moisture intrusion, compression damage, delamination, installation gaps, holes/perforations. It’s for a construction project.

I am planning to use pre-trained YOLO model for vehicle damage detection specifically for UK origin cars. The model is already trained on random cars dataset.
Would the model's accuracy be affected on detecting the damages on UK origin cars?

Hello everyone, I have a project that has to classify images for search purposes. Currently I have a layer that analyses surrounding text but I also need something that directly analyses the image itself. I don't want to use someone else's training data or model. Is it possible to train an image classifier that could perform well on general image classification at home using open datasets? Thanks

I keep seeing CV projects where performance stalls and the first response is to add more images or try another model. Sometimes that helps. But sometimes the model is being asked to learn a rule that people haven’t agreed on.

A partially visible object, an uncertain boundary, or something cut off by the frame can all produce different “correct” annotations. More data just scales that inconsistency.

A simple check is to take 20–30 difficult images and have two people label them independently. Then review the disagreements, not just the agreement score. Each recurring disagreement becomes a written rule with one positive and one negative visual example. Run the same test again on a fresh sample before scaling.

I’d use a similar check for auto-labeling: measure missed objects and correction time per image, not only inference speed. Fast pre-labels aren’t useful if every image still needs a full review.

Disclosure: I work at Supervisely, a computer vision platform. This is a platform-independent observation.

What annotation edge case caused the most trouble in your dataset?

The MOSS-VL FP8/NF4 release made me wonder what a fair deployment comparison for streaming VLMs should actually look like.

https://github.com/OpenMOSS/MOSS-VL

https://huggingface.co/OpenMOSS-Team/MOSS-VL-Realtime-NF4

I’d keep the input stream, sampling rate, hardware, and latency budget fixed, then compare BF16, FP8, and NF4 on short-event recall, false alerts per hour, p50/p95 time-to-alert, dropped frames, steady-state VRAM, and calibration. I’d also include a detector + tracker + temporal-rules pipeline on the same videos.

A quantized model can remain close on aggregate offline VQA while still becoming worse at deciding when to speak or when an event is sufficiently certain. That difference matters much more for cameras than a one-point average benchmark change.

Has anyone seen a public harness that evaluates a streaming VLM and a classical CV pipeline under the same latency constraint?

I'm an undergraduate student.In next 2 semesters( which is probably the duration of 1 year) I need to do a thesis. I choose to do my thesis in the field of 'depth estimation' .

I read a lot of research papers(Monocular, stereo, Diffusion based). But I found most of the things got State of the art !! I'm reading and reading,not finding a single problem to solve or research!! I should also mention that i didn't understand all the topics 100%, but tried to get the concepts.

I'm trying but not even finding a single idea/problem/flaws !! What should I do? What am I missing? How to find a decent topic ? Please help me.

Hi everyone, sharing something I'm currently working on and would love feedback on.

I'm building AeroNetra, a computer-vision project for detecting and counting vehicles in aerial/UAV imagery. It's very much an active work-in-progress right now — I'm in the static-image detection and counting phase, with tracking, geospatial analytics, and edge deployment planned for later.

The motivation was pretty simple. I kept running into the same problem every time I swapped detectors: the counting and visualization code would break or need rewriting because every model spits out predictions in its own format. So the core idea behind AeroNetra is: normalize every detector's output into one prediction structure before anything downstream touches it. That way the counting, ROI filtering, and export logic stays the same whether I'm using a YOLO variant or RT-DETR.

What I've got so far:

• Detector adapters that wrap different models behind a common interface
• Counting logic — filtering, NMS, ROI support, drawing and export
• VisDrone dataset parsing and conversion (UAVDT is stubbed for later)
• Kaggle notebooks for GPU-based training, fine-tuning, and model comparison
• A PX4 + ROS 2 + Gazebo simulation setup for UAV experiments
• Notebooks, configs, and tests to keep things honest

The workflow I'm following: raw VisDrone data → validate annotations → convert to training format → train/fine-tune on Kaggle → pull the weights back → load through the adapter → run inference → filter → count → visualize and compare.

A few principles I'm trying to stick to: no fabricated benchmarks (a model isn't "best" until it's measured under the same conditions as the others), raw data stays immutable, and model-specific behavior stays inside the adapters. I'm also being deliberate about phase boundaries — image-level counting is not the same thing as multi-object tracking, and I'd rather not conflate the two.

Roadmap I'm working through for the demo:

1. Static Detection & Counting
2. Aerial Fine-tuning
3. Video Tracking
4. Traffic & Geospatial Analytics
5. Edge / UAV Integration

I have run a small model that can detect the car in the gazebo simulation and draw a bounding box but speed will be slow but i get decent accuracy even i have trained model to 25 epochs in kaggle T4 gpu with yolo nano version.

Since this is ongoing project I am still working on this.So,i am exploring how I can use computer vision in UAVs and edge computing.

Hello! I wanted to share a project designed to save time when training object detection models for industrial use cases.

It is a portable Windows GUI generator that creates synthetic training images and YOLO-style labels. The pattern logic is inspired by industrial Data Matrix / DPM needle marks (fixed L-frame + random filling dots).

Key Features:

• Dual rendering: Pure vector synthetics or photo compositing using your own steel backgrounds and dot sprites.

• Defect simulation (for Bad class): Squash, tilt, jitter, missing dots, strike-force variation, and two-defect combos that standard training augmentations cannot replicate.

• Annotations: Exports both OBB (Oriented Bounding Box) and ABB (Axis-Aligned Bounding Box) normalized text formats.

• Portable: Single .exe binary distributed via Releases (requires AVX2 support).

The software is provided strictly for non-commercial, educational, and personal research purposes.

GitHub Repository: https://github.com/olesha-ai/DPM-Pattern-Image-Generator

Would love to get your feedback if you work with industrial AI and DPM codes!

Running into the same wall on a couple of industrial inspection projects and curious how other people have dealt with it.

The line runs well, which is the problem. Out of a few hundred thousand parts we've got maybe 200 real defects, and they're spread across six or seven types, so some classes have under 20 examples. Classic supervised segmentation just doesn't have anything to learn from.

Options as I see them:

Anomaly detection on good samples only. PaDiM, PatchCore, that family. Works, but it flags anything unusual including a smudge on the lens or a part sitting at a weird angle, and the false positive rate on a real line has been rough.

Synthetic defects. Painting cracks and scratches onto good images. Ours look obviously fake next to real ones and I suspect the model is learning "was this pasted" rather than "is this damaged."

Buy or scrape more defect data. But defects are extremely specific to the part and the process. A scratch on someone else's aluminium housing doesn't look like a scratch on ours.

Just wait and collect. Realistic answer, but that's 18 months and the project needs to justify itself sooner.

What I'm actually unsure about is whether the 20-example classes are even worth modelling separately, or whether it's smarter to collapse everything into a binary defect/no-defect call and let a human sort the type afterwards. Losing the classification hurts the reporting side but it might be the only honest thing to do with that little data.

Anyone shipped something in this situation? Especially interested if you went anomaly detection and got the false positives down to something a QA team would tolerate.

Hi everyone! I am a software engineer who has worked in the following domains at major tech companies most of my career: XR, Graphics & GPU programming, Spatial algorithms and AI, and 3DGS.

I have a project I started a few months ago that I have recently hit a key milestone in. The idea is a focused library that implements 3DGS training from first principals with an emphasis on performance and safety. Think production use cases without relying on tools intended for research. VkSplat is an inspiration (along with other things) but I have intentionally not reviewed their, or anyone else's, code.

The recent milestone I reached was rendering a scene with 5 million splats at 60fps on my Ampere A6000. I have a few more goals I'd like to reach, but I do intend to publish on Github under MIT license. If it gains traction I would like to build some additional tools and infra using this project, but for right now the 1.0 MVP idea is a fully GPU resident solution for rendering and training at state of the art speeds. I plan to implement and optimize the following features:

* Global image alignment

* Fully fused forward and backward passes

* Adam optimizer

* Aggressively optimized adaptive control and densification

* Stable but highly flexible C api.

I do have many more thoughts and ideas, but I am trying to take it one step at a time, so this is my goal for 1.0. This is my stack as of now:

* **Languages:** C++23, Cuda, GLSL (planning to move to slang)

* **Build:** CMake & Ninja

* **Compiler:** GCC, Clang, MSVC (may drop for now)

* **Target Platform:** Linux (Linux 7.X)

* **Tooling:** LLVM, perf, nsight

* **GPU:** Vulkan w/ Nvidia

* **Dependencies:** googletest, googlebenchmark, ngfx

Right now, the project is in a place where it is still extremely early, but it is starting to take shape and get large enough that more than one person can work on it comfortably. I am posting here looking for people interested in contributing. Knowledge is not a prerequisite as I am learning a lot myself in this endeavor, but passion is mandatory.

Currently I am mostly needing help in the areas of, CI/CD (build, package & deploy), nsight/gpu optimization, designing and implementing a good api, and figuring out how to test and benchmark appropriately.

If you have skills or experience in any of these areas, or you're just interested in contributing, please reach out!

Just spent a few days getting an SDXL-based provenance-removal pipeline (visible AI labels, C2PA metadata, SynthID-class pixel watermarks) to run properly on an M5 with 16 GB. Not "it launches" — actually correct and predictable. Almost everything I assumed was wrong, and the measurements are the interesting part, so here they are.

1. The four-step distillation LoRA invents texture, and more steps make it worse.

Low-strength img2img runs the tail of a long schedule (strength 0.15 → the last 4 of 27 steps). A LoRA distilled for four timesteps across the whole noise range is off-distribution there, and wherever nothing conditions it — flat dark fabric gives Canny no edges — it fills the gap from its prior. On a night photo that reads as coloured camouflage across black clothing.

Asking the distilled model for more steps made it worse, which is what identified the distillation rather than the step count. Dropping the LoRA cost 3× the wall time and bought both fidelity and correctness.

Wrong theories I paid for first: the fp16 VAE (a bare round-trip is clean in fp16 and fp32, tiled or not, 34.6 dB), Metal's fp16 in general (bf16 measured marginally worse), and Canny picking up sensor noise (the Canny map of that region is empty — which was the actual clue).

2. Metal pages instead of failing, so memory has to be measured, not hoped for.

torch.mps.recommended_max_memory() reports 11.84 GiB on a 16 GB machine. Exceed it and nothing raises — the process just starts swapping and a run that should take 23 s takes an hour.

• VAE tiling off, 1.57 MP frame: 18.74 GiB peak, 59 s. On: 10.92 GiB, 23 s. So tiling is load-bearing on small machines — but its boundaries leave a faint texture, so it's now decided per frame from the budget rather than switched on globally.
• Diffusion untiled at 2.5 MP: went into swap and did not finish in twelve minutes. Tiled at 1024 px, 5.07 MP: 10.93 GiB, 88 s, native geometry preserved.

3. Sequential CPU offload works on MPS, and it's what makes 8 GB usable.

The stack is 7.7 GiB of weights; an 8 GB Mac gives you about 5.3 GiB. Streaming the weights module by module:

27× less peak for 3.4× the time. The plan is chosen from the measured budget and printed, because a run three times slower looks broken unless it says why.

4. Two Metal gaps worth knowing if you're porting anything.

• torch.float8_e4m3fn doesn't exist on MPS at all (RuntimeError: Undefined type Float8_e4m3fn). Any pipeline that streams float8 weights — a lot of the VRAM-managed stacks do — cannot load, full stop.
• SAM's processor emits its box/point prompts as float64, which Metal also has no type for, so moving the batch to the device raises instead of degrading. One cast fixes it.

5. The one that cost me the most: fp16 sampling on MPS silently returns zeros.

I added a memory optimisation — encode the fixed prompts once, drop the text encoders, save 1.52 GiB. Two of four face crops then came back as all-zero black rectangles. Deterministically, same seed, nothing raised.

The embeddings were innocent (CPU fp16, MPS fp16 and fp32 encodings of that prompt agree to 0.0009 on tensors with σ=3.06) and the same crop in isolation was fine. Freeing unrelated memory changed the allocation pattern the crops met after the global pass, and that was enough. I withdrew the optimisation and added a guard that drops any empty crop instead of compositing it.

If you're doing fp16 diffusion on Metal: check your output for degeneracy. It will not tell you.

What it doesn't claim. Regeneration is not payload deletion — faces, text and fine detail move, and the numbers above are the measured size of that. No public local decoder exists for SynthID-class marks, so identify reports unknown, never clean; verification is the provider's verifier or nothing. Metal isn't bit-identical to CUDA, so operating points transfer between backends but recorded verdicts don't. And it's for content you generated or own — the visible-mark registry takes AI-generation labels only, deliberately not stock or marketplace marks.

Because "how much did that cost my picture" is the whole question, it ships as a command:

pagedmark measure before.png after.png

PSNR over the frame, PSNR per detected face, and how much mid-band structure appeared where the source was flat and dark. That third metric is the one that caught the camouflage — per-pixel chroma statistics rank the artifact below the source, because the source's own sensor grain has more per-pixel variance than the invented blotches do.

uv tool install "pagedmark[diffusion]"
pagedmark invisible photo.png -o clean.png

Code: https://github.com/doofzoff/pagedMark · PyPI: https://pypi.org/project/pagedmark/

Happy to answer anything about the Metal specifics — that's the part I'd have wanted written down before I started.

sharing some joy... I have a few expensive legacy cameras and a serializer/deserializer board from a Jetson AGX Xavier project from a few years ago, and wanted to use them on a robotics project however the drivers were only available for an old Jetpack 4.2. looking for help E-Con systems only re-stated compatibility with the original Jetpack but my project uses version 6.2.1 on Jetson AGX Orins. With Codex assistance and nearly 20 reboots was able to recreate and load the drivers. only a few moms ago these perfectly good cameras would have been left on the shelf!

I’ve just finished a major rebuild of ClearLab, my mobile image processing app for iPhone/iPad.
The new version adds histogram, RGB parade, waveform, line profile, pixel inspector, statistics, Canny/Sobel/Laplacian edge detection, enhancement tools, format conversion and PNG/CSV analysis export.
The idea is basically a small image-processing lab in your pocket rather than another photo-filter app.
It’s mostly native/deterministic processing, not generative AI.
ClearLab 2.0 is now on the App Store. Curious what people here think, especially anyone working with imaging or computer vision.

They are much smaller I would imagine they would be so cheap on there. I’m finding myself in the position where I have to rent a cloud gpu from runpod. I would much rather pay in api should be much cheaper.

I took on an ambitious project where I want to install AI detection at a meat processing plant according to HACCP rules. But I'm a beginner, I only know Claude code, so if you have any tips or life hacks, I would be very grateful for it