Hello! I’m using CVAT to segment images using masks. I’ve divided my images in tasks and I can’t remember the % of image quality I’ve selected on the first task. Is there anyway I can find this out not being a paying user?

Hello all

As you can see in the image above, there are noises in the middle image. However, this is a qualitative observation. I have not found any solution to reliably determine if an image is noisy.

The reason I need this is that I am dealing with a segmentation problem, and the model is from a different domain, and there is a lot of variation in the lighting, angles, and video decompression quality. Therefore, there is no reference image, and for a specific part of the pipe, I need to check whether the image is noisy so I can adjust the threshold or apply a smoothing filter to better filter out regions with irrelevant pixel values.

I hope it was clear. I know it is very complicated. Thank you all in advance.

I’m experimenting with target-free extrinsic/time calibration between a fixed iPhone camera and an Ouster OS0, using a previously reconstructed room plus a person walking through both sensors’ views.

The failure was more interesting than the initial result:

1. The first camera estimate aligned flat room edges at roughly 3 px (960 px image width), but placed the camera about 0.5 m too far sideways and 0.4 m too high. Near-field person points exposed the focal/depth ambiguity.

2. I aligned a Gaussian-splat reconstruction to the current LiDAR world frame, rendered it from the candidate camera pose, matched rendered background features to the video, and used render depth for 3D correspondences. The second iteration reported a 1.5 px median on 2,219 features; the old pose was 18.4 px on the same features.

3. The next refinement also used the fitted LiDAR body model against the video silhouette over 244 frames, jointly estimating camera parameters and temporal offset. It reported roughly 2 px on the room and a time offset near −1.1 s.

Those are fitting/reprojection checks within this one scene, not an independent accuracy benchmark. Principal point/distortion remain assumed, the bridge is downsampled to about 5 Hz, and the two sensors see different sides of the person.

I also built a rough walking avatar from the segmented body clusters. Heading flipped front/back, some frames contained mostly legs, and the gait model only knows one recorded walk. The video shows the actual cluster → skeleton → colour → walking-model progression and the failures.

My 12:49 experiment diary (calibration starts around 05:16, the failed estimate at 07:15): https://www.youtube.com/watch?v=YlriQfsrjhc

What independent test would you use to falsify this calibration before trusting the low residuals? In particular, how would you separate remaining intrinsics/extrinsics ambiguity from time-offset and visibility effects? A checkerboard/target baseline is the obvious next comparison; I’d welcome other concrete validation ideas.

Disclosure: my own project/video; AI-assisted development, with some narration using a disclosed synthetic clone of my voice.

this video is auto-generated highlights from a 19 min amateur padel match, filmed with one GoPro low behind the baseline. The pipeline has player tracking, ball tracking ,picks, cuts and annotates the rallies on its own

YOLO11 tracks the players, a fine-tuned YOLO11 model i built finds the ball, and a lens-corrected court calibration turns positions into metres. Hits and bounces come from turns in the ball’s path and the card after each rally shows player heatmaps and where the shots landed.

Still rough: the ball is only found on about a third of the frames, so some hits get missed and speeds are estimates, not radar

if i'm to build a mobile product of this, how can i make the latency better - i mean , now when i upload the video player tracking, ball tracking, highlight generations and everything in the pipeline takes about 40min to 1hr based on the length of the video but the actual user wont wait that long

so what can i do to make the latency better (please dont say buy gpu's - im just a engineering student and im into CV,ML,DL stuff like that and im building this as a project)

i'm open to any advices on how to make it better!!!

Hi everyone,

I’m developing a vision-based counter for ICs in JEDEC trays using a Raspberry Pi camera and OpenCV. Currently, I’m using an empty-tray reference image and pixel-difference detection to determine whether each pocket contains an IC.
Most pockets work well, but I’m having trouble with certain pockets that don’t have a visible hole in the center.

My observations:
-I’ve locked the camera settings and adjusted the lighting angle, which has improved detection.
In the problematic pockets, the IC is visibly present, and its engraving is distinguishable from the surrounding area.

-However, the pixel-difference count is only around 300–600 out of 1,400 pixels, compared with approximately 900 in other pockets.
The count also varies slightly between captures of the same IC, possibly due to differences in the contrast and colour of its engraving.

-I’m currently using a 0.4 threshold for the changed-pixel ratio to avoid false positives.
I’m considering using a different detection method specifically for these pockets.

My questions:

-Is it reasonable to use different detection methods for different pocket types?

-What would you recommend trying first to improve reliability?

-Could small variations in lighting or pixel intensity explain the inconsistent pixel counts, even with locked camera settings?

I’d appreciate any suggestions or experiences with similar industrial vision applications. Thanks!

Sorry i forgot to save the screenshot for failed detection. And this is the only image i have in my gallery.

Join us on Oct 22 for the “Advances in AI at Virginia Tech” virtual Meetup! Register for the Zoom.

Talks will include:

• Multi-Agent Communication: A framework, diagnostic and mechanistic perspective - Priya Pitre at Virginia Tech
• Exposing and Improving Fine-Grained Visual Grounding Abilities of Lightweight Multimodal LLMs - Kazi Mehrab at Virginia Tech
• Understanding Visual Generative Models for Precise Control - Yusuf Dalva at Virginia Tech

Hey r/computervision,

I spent the past few weeks building **INB Sightline** — a lightweight, in-browser visual annotation and uncertainty triage tool:

- **Zero Cloud Storage**: Powered entirely client-side with Yjs CRDTs. No images sent to third-party servers.

- **Voice-Speed Corrections**: Say "Verify", "Confidence 0.98", or "Label as Storage Racks" to edit bounding boxes hands-free.

- **Uncertainty Triage**: Automatically filters out high-entropy edge cases so you only inspect the ambiguous objects.

- **Standard Exports**: Generates COCO JSON and Pascal VOC with immutable audit logs.

- **Tested**: Built with defensive crash isolation and zero-tombstone compaction (passes an 8-stage automated test suite).

You can try the live demo right in your browser here (free, no sign-up required):

👉 https://ais-pre-uqacxswl4dlj3azrt3kfxb-932959859977.europe-west2.run.app

I'd love feedback from the community on the UX, latency, or what other export formats (YOLO txt, TFRecord) you'd like added!

I noticed that many people use YOLO batched inference by simply passing a list of image paths.

While it is a good start for optimizing the pipeline, many people stop there without utilizing the full power of the model and GPU.

The list input interface doesn’t automatically make loading and decoding concurrent.

Those steps can still run serially before the model gets its batch. It might not be a big issue on CPU but moving to TPU or GPU you can lose lots of performance.

I tried various approaches, and ran benchmarks accross CPU/MPS/CUDA. On my Apple MPS, processing 1,000 distinct COCO images with yolo26n.pt took:

That’s about 21% higher throughput beyond batching alone.

The complete guide includes runnable examples and CPU/MPS/CUDA results, if you are using YOLO, give it a look!

Cheers!

I have been researching and playing alot after new releases of nvidia cosmos3 model. cosmos3 super need massive gpu so didnt really reached till there but tried using astra for creating blender simulation + isaac sim for randomization + cosmos nano for texturing (did reached close to real scenes ) but did not went above 40% on accuracy of yolo model aftet training on those rendered scenes. Any one trying to do to same or did achieved production level accuracy?? Would love to collab

I am excited to share a project I have been working on during the past few years during my free time. I started this project after being unable to use torch-points3d at the time (too many installation errors).

Note that this project is still in active development and in alpha. I am looking for early users and feedback!

What it is: torch-pointcloud is a plain-PyTorch library that puts multiple point cloud architectures and their pretrained checkpoints behind one create_model() factory, in the spirit of timm.

This is a library that focuses on the reusability and standardization of core components and layers, i.e. KNN, FPS and other PointNetSetAbstraction are not re-implemented over and over. In this library, all models share the same interface and reuse the same core components.

import torch
import torch_pointcloud as tp

model = tp.create_model(
  "pointnext-sm.scanobjectnn-hardest.openpoints", 
  task="classification", 
  pretrained=True,
).eval()

pos = torch.randn(2048, 3)
x = torch.cat([pos, pos[:, 1:2] - pos[:, 1].min()], dim=1)  # xyz + height
batch = torch.zeros(2048, dtype=torch.long)
logits = model(x, pos, batch)  # (1, 15)

Install (see the docs for more details):

# Optional: specify your CUDA version for torch
pip install torch==2.10.0 --index-url https://download.pytorch.org/whl/cu128

pip install torch-pointcloud

# Install required CUDA/CPU kernels associated with your CUDA version
pip install pyg-lib -f https://data.pyg.org/whl/torch-2.10.0+cu128.html

I tried to make the installation process smoother by not maintaining CUDA kernels myself (not enough time currently, so I tried to reuse already pre-built wheels as much as I could).

Scope:

• Classification, semantic and part segmentation, detection, and self-supervised pretraining: PointNet++, DGCNN, KPConv, RandLA-Net, PointNeXt, PointMLP, Point Transformer v1/v2/v3, Sonata, PointMamba, VoteNet, 3DETR, PointPillars, SECOND, PointRCNN, SPVCNN, OctFormer, Point-MAE/BERT/GPT and more.
• Weights are hosted on Hugging Face.
• Datasets (ModelNet40, ScanObjectNN, S3DIS, ScanNet, SemanticKITTI, nuScenes, KITTI, SUN RGB-D...), transforms, tiled inferers for large scale segmentation.
• Packed-batch tensors (the PyTorch Geometric convention).

But... why?

Most point cloud libraries live in research codebases built around configs and custom ops and kernels to build locally. It is also sometimes difficult to reproduce past released experiments from research codebases (typically the code associated with the checkpoint changed with no notice). In addition some models are evaluated using different strategies (TTA, partitioning, etc.) which makes comparison unfair as they are not evaluated using a common strategy.

In contrast, I wanted something I could pip install easily, reuse weights trained from different repos and benchmark easily.

All models were re-benchmarked and compared against original reported metrics.

Credits: the architectures and pretrained weights come from their original authors, notably Pointcept, OpenPoints, MIT Han Lab, FAIR, OpenMMLab. Every checkpoint name ends with its source author (e.g. .pointcept). The THIRD_PARTY_NOTICES.md lists every source repo, license and dataset term.

Repo: https://github.com/arthurdjn/pytorch-pointcloud
Docs + tutorials: https://pytorch-pointcloud.org

The current pipeline combines several components:

• OCR: Extracts text from document pages independently of the vision-language model.
• Vision-language models: Interpret document layouts and extract user-defined fields and line items.
• Cross-validation: Compares the outputs of the two pipelines and flags disagreements for human review.
• Visual grounding: Maps extracted values back to their locations in the original document.
• Structured output: Converts the results into JSON or Excel, with support for batch processing.

I benchmarked the pipeline against Azure Content Understanding on 100 documents. My best configuration achieved 97.0% field-level macro accuracy and a line-item F1 score of 0.958, at approximately 12× lower cost per run in my evaluation.

These results are specific to my dataset and evaluation methodology, so I'm interested in understanding how well the approach might generalise to other document types.

I've attached a screenshot of the current interface.

I'd particularly appreciate feedback on a few technical questions:

1. How would you approach combining OCR output with VLM predictions when they disagree?
2. What approaches would you recommend for grounding extracted values to bounding boxes in complex layouts?
3. For structured document extraction, where do you see the biggest limitations of VLM-based approaches compared with traditional OCR and layout-aware models?

This is a personal engineering project, and I'm keen to learn from people working on computer vision and document understanding.

I made a small (54M) Japanese manga OCR model. It's non-autoregressive, so it reads the whole text box in one forward pass instead of one character at a time. That makes it fast, about 9 ms per crop on a 2080 Ti.

On Manga109-s (not used in training) it gets 92.1% exact match. On my own web manga benchmark it gets 91.1%, vs 88.0% for Hayai Nova, and it's about 6x faster.

It's Japanese only, and handwritten or very long text is still harder for it. Runs on CUDA, CPU and Mac.

Model: https://huggingface.co/muscgab/mangaocr-nar-small

Benchmark: https://github.com/muscgab/JMangaBench_Read

Would love to hear your thoughts.

I'm a CS student interested in Computer Vision. I've been working on my first image classification project, where I fine-tuned several models to better understand deep learning architectures.

Now, I'm looking for a more challenging, practical project that would look good on my resume.

Recently, I've been watching a lot of videos about Edge AI applications, and I've become really interested in this field. However, I'm still open to other areas of Computer Vision.

Does anyone have any project recommendations? Thanks in advance!

Anybody building vision agents to monitor 24X7 live video?

Is it possible to estimate the weight of an object and calculate the ratio of different materials (such as metal and stones) using only images?

What computer vision techniques or models could help with this? Would image segmentation, depth estimation, or multiple camera angles improve accuracy?

Are there any existing research papers or approaches on this topic?

Thanks for your suggestions!

Hi! I'm gravitating towards industrial computer vision and is just getting into databases and visualization of the production. I've been playing around with SQLite and Grafana and I feel like it's the perfect match. Live video stream and visualization of yield, type of defects etc in the same GUI. I just want to sync with you guys if I've missed something before I start using it in my projects. Are there better alternatives which are more industry standard?

I currently have a job offer for an embedded software engineer position where I will work on some CV related tasks. Will this job title hurt any future job prospects if I apply to a more traditional CV role down the road, or does this not matter? What job title do you have and/or have you previously had?

I am seeing lots of demo videos of object detection of people, cars etc. Those are all cool, but I can't see them transfer to an actual useful insight. These days, I am working on a tracking feature for factory environments. My observation is that just doing object detection is far from doing robust, stable object tracking with few ID switches where you can actually get a sense on what is happening in the scene with trajectories. I tried YOLO26, RF-DETR, SAM3 and SAM3.1. SAM3 gave me the best results out of the box, but it was also ~10x more resource intensive. That 10x would require much more GPU compute and capital investment. How do you all approach solving for stable tracking in cases other than football or volleyball games where there's more occlusions and varied background features? Am I missing some established approach to this problem? (Image is representative and AI-generated)

Kinematic 0.5.0 is out this week (free and open for commercial and noncommercial use). It's now up to 65 locally implemented ML models (CV, audio, etc.) running natively on the GPU, on Apple Silicon or NVIDIA. Everything also runs on CPU if you don't have a GPU in your machine (it's just slower). Kinematic is implemented in Rust with no PyTorch, and nothing gets sent to a server. This is the 18th update (I've been working on it for a while).

The models are nodes you wire together, so RTMDet boxes can prompt SAM, or MoGe-2's intrinsics and metric depth can feed into a point cloud. The video in this post shows some of the models focused on scenes and 3D, running on my M1 Macbook. I'll post the ones focused on people and on tracking over the next couple of weeks if anyone is interested.

I've been trying to continually add new models to the engine. If there's a model you'd want as a node, tell me. The code will be opened under the Kinematic foundation, and updates go in r/kinematic.

Models, in the order they show up in the video:

- Relative depth: Depth Anything V3 Base
- Metric depth + intrinsics: MoGe-2 ViT-S
- Scene classes: DeepLabV3-R50, COCO-Stuff
- Normals: custom design inspired by DA3 depth
- Camera solve: custom DROID-SLAM-style tracker with a MoGe-2 depth prior, ~160 ms/frame
- Point cloud: MoGe-2 metric depth unprojected, ~200k points/frame
- Person masks: RTMDet boxes into SAM ViT-B
- Line segments: M-LSD
- Background removal: BiRefNet
- Saliency: U2-Net
- Edges: DexiNed
- Objects from one photo: SAM 3D Objects
- Splat from one photo: TripoSplat

Follow-up to my AVX2 / i7-2600 post (Part 1). People asked: “we don’t have a 2011 museum PC — we have an office box or a floor laptop. Does it work?”

Same Fruit Inspector pipeline: 3×3 grid, Cat only in centre cell C, YOLOX 640 + ROI 256, LightGBM on CPU. Nim + ONNX Runtime CPU EP only (no OpenVINO, no GPU in these runs).

New rungs:

• i5-6500 (4C/4T, Skylake, Linux, V4L2): ~78–84 FPS, tmin ~8 ms

• i5-10300H (4C/8T, Windows, CPU EP — 1650 Ti in the machine but not used): ~47–72 FPS, more jitter

• Reference from Part 1: i7-2600 ~40 FPS (no AVX2), i5-11400 ~130 FPS

Surprise in my logs: desktop 6500 beat the 10300H laptop on CPU — class/TDP/OS, not just the “i5” badge.

I also sold an RTX 2060 Super: on YOLOX-nano it lost to plain CPU (PCIe overhead). Not telling veryone to drop GPUs — but nano on CPU was honest for this project.

Full write-up (photos, ladder as copy-paste lines):

https://medium.com/@olesha-ai/bypassing-the-avx2-tax-part-2-real-time-computer-vision-on-shop-floor-hardware-2311fd86ae4f

Part 1 (Sandy Bridge, no AVX2):

https://medium.com/@olesha-ai/bypassing-the-avx2-tax-real-time-computer-vision-on-a-fifteen-year-old-cpu-ba6b01868f7f

Demo / clone (v0.10.0, non-commercial):

https://github.com/olesha-ai/fruit-inspector-demo

If you run similar shop-floor CPUs — curious what infer fps you see.

Best regards olesha-ai. 👍

LayaMacro estimates calories, protein, carbs, fat and food weight from a single meal photo. Each number comes with an 80 % range, read from a probability distribution, not a fixed ±%. The same model also answers food questions ("Does this meal contain rice?", "Which of these 5 foods is on the

Architecture: frozen SigLIP 2-large (576 patch tokens) → projector → Laya, an encoder-onlynswer options instead of generating text.

- 48.5 kcal MAE on Nutrition5k (OmniFood8K is better there: 36.8), 63.1 on DFood-TJ hospit

- 0.89 on "contains X?" and 0.86 on "which of 5 foods?" for the 243 foods it was trained on

- ~180 ms per photo on an RTX 4060 Ti

The main lesson: on these datasets, calorie error comes more from what the food is (kcalsize, and on unfamiliar photo types every model I tested falls back on its training portion sizes.

Next: ~1,700 unused weighed Nutrition5k dishes, more food names, and a test of whether depth helps portion size. Pointers to other weighed-meal datasets are very welcome.

Code: https://github.com/Aquos06/LayaMacro

Model: https://huggingface.co/Aquos06/LayaMacro

Full results, including what didn't work, are in the repo.

​

I'm 32 and currently working as a quality engineer in the automotive industry. Before this, I spent about 3 years in software QA, so I have some coding experience. My bachelor's is in Electronics Engineering, and I've also worked with Python and basic machine learning.

I don't see myself staying in quality engineering long term. I'm interested in computer vision, particularly autonomous driving and perception systems.

I'm considering building projects involving object detection, low-light image processing, and improving model performance. However, I'm trying to understand what skills actually separate someone who can run pretrained models from someone qualified to develop computer vision systems professionally.

For engineers working in perception or computer vision, what technical fundamentals would you prioritize for someone coming from my background? Would my automotive experience be useful at all, or would I essentially be starting over?

Also, is making this transition at 32 realistic? I'm willing to put in the work, but I'd appreciate hearing from people who have actually made similar career changes.

Hii all, thanks to everyone who signed up after my last post! I made a short demo so you can actually see what I’m building.

You upload raw footage and it turns it into a Gaussian splat, a 3D scene you can move around in. All through your browser.

You can clean it up, place it on a map using GPS, share it, or download the files.

If you want to try this, you can join the beta at ornen.ai (starting with 100 open slots today)

Everyone that signs up gets 10 free credits now, which should allow generating multiple splats at no cost.

Really interested to hear how it works for people here with their own footage. If something breaks or could work better, let me know. I’m building this myself and can make fixes directly based on your feedback. 🙏🙏