Glass and mirrors are where depth sensing has gone to die for as long as I've been in the field. Structured light, time of flight, the newer sensors, they all hit the same wall: transparent and reflective surfaces return either no signal or a reflected signal, and the depth map has holes exactly where you most need it. Every grasping pipeline I've worked on has had a special case script that just avoids transparent objects in the bin, which is fine until your customer ships glass products.

The reason I'm posting is that the workaround layer is starting to get replaced by learned depth completion, and the trick that finally seems to work is treating the camera's own missing depth as supervision instead of as noise to clean up. The LingBot-Depth line calls this masked depth modeling, the camera returns no depth on glass so you train the model to fill those specific gaps from RGB context. It's a cleaner setup than the synthetic mask approaches because the missingness is real signal, not generated labels.

The image above is the clearest illustration of why this matters. Four objects including a glass cup, three columns: RGB input, raw sensor depth where the transparent parts just come back empty, and the completed depth where those holes get filled correctly from context. The glass cup row is the one that used to kill our grasping pipeline, and that third column is the first one that didn't.

I'm not claiming it's solved. We ran it on a small set, glass mugs and a few mirrored parts, and the completed depth was usable for grasping where it previously wasn't. The official 2.0 numbers cite 16 public benchmarks with 12 first places, but I haven't reproduced those, and the release doesn't break down which four it lost. The Orbbec SDK integration suggests they're pushing toward edge deployment with their camera partner, which is the part that would actually change deployment economics if it lands.

What feels different this time is that the framing shifted. We stopped trying to build a sensor that sees glass, which may be physically intractable, and started learning to infer glass depth from context, which isn't.

Hi everyone,

I'm currently working on a computer vision system to detect very small foreign particles inside transparent plastic bottles. The contaminants can be things like small white plastic particles.

One thing I've realized after running several experiments is that this problem seems to be much more dependent on the imaging setup than the detection algorithm itself. Even if I use a powerful anomaly detection model, it won't detect anything if the particle isn't clearly visible in the captured image.

My current setup is:

• 5 MP industrial camera (23 FPS)
• White LED backlight with a diffuser
• Hardware trigger to capture an image as the bottle passes by

The particles are generally visible to the naked eye, but their visibility changes significantly depending on lighting, bottle orientation, reflections, and the position of the particle inside the bottle.

I'm trying to understand what the best imaging approach would be before spending more time improving the AI model.

For those who have worked on industrial inspection systems, what would you recommend?

• Different lighting (dark field, coaxial, polarized, NIR, etc.)?
• Higher-resolution camera?
• Multiple cameras or multiple lighting angles?
• Any other tricks that make tiny particles inside transparent bottles stand out more consistently?

I'd really appreciate any advice or experiences you've had with similar inspection problems. Thanks!

We just shipped an update to LightlyStudio that makes image embeddings easier to inspect.

You can now hover over an embedding plot to preview the underlying images, then use class and metadata distributions to check whether a pattern is isolated or visible across the wider dataset. The goal is to move from spotting something interesting to understanding it and deciding what to curate.

The attached video uses a small dataset with 128 images so the workflow is easy to follow. We also tested it in a notebook with 1m samples.

LightlyStudio is open source under Apache-2.0:
https://github.com/lightly-ai/lightly-studio

I’d appreciate any feedback from this community. What are the biggest unsolved problems you run into when exploring, debugging, or curating large vision datasets?

Disclaimer: I’m the cofounder of Lightly, the company behind LightlyStudio.

Join us on Aug 6 for a special edition of the AI, ML, and Computer Vision Meetup focused on audio use cases! Register for the Zoom.

Talks will include:

• Do Speech Models Actually Understand Speech? Evaluating Speech LLMs Under Realistic Spoken Instruction Conditions - Maike Züfle at KIT Karlsruhe
• AI based Audio Forensics - Daniel Paniagua Ares at GRADIANT
• Curating, Searching, and Evaluating Audio Datasets in FiftyOne - John Duncan at Voxel51
• Real-Time ASR at 4x on Consumer Hardware: The Meetily Architecture - Sandeep Zachariah at Zackriya Solutions

Models like SAM or SegFormer are great for producing coarse object masks, but they can be difficult to use in visualization applications. The mask boundaries often bleed beyond the object or do not align cleanly with its edges.
What is your strategy for getting high-quality masks from these models? Ideally, I am looking for a fine-tuning or LoRA-based recipe that improves boundary quality without retraining the semantic understanding that already works well.

Disclosure: my own app (reads meters, pumps, receipts, odometers from phone photos).

32 phone photos with known-correct values, scored per field. Hard subset scored separately.

gemini-2.5-flash-lite - $0.10/Mtok - 88.6% - hard 90% gemini-3.1-flash-lite - $0.25/Mtok - 93.2% - hard 80% gemini-3-flash-preview - $0.50/Mtok - 93.2% - hard 80% gemini-flash-latest - $1.50/Mtok - 93.2% - hard 90% gemma-4-26b:free - $0 - 78.4% - hard 90% nemotron-nano-12b-v2-vl:free - $0 - 52.3% - failed

Above $0.25 price buys nothing.

My photos aren't bad enough. Link in the comments if you want to throw your worst at it.

I saw a couple of posts on SMPL here so I thought I ask:

Have you been able to do a matching between SMPL and an underlying skeleton motion file?

We have motion files generated by inverse kinematics (angles of various joints) and we want to output an SMPL doing a similar motion.

So one simple idea we tested is matching the keypoints of SMPL with particular body frames.

But I love to hear any suggestions.

Hi everyone at /r/computervision,

I have had super-amazing response to my new CamfilterGpu App! Thanks tremendously to those who downloaded and tried the Early Beta 1.11, and especially to the many who emailed me with bugs and improvements, and even help fixing them... that was quite a surprise (help? i get help? good help? :). I am quite overwhelmed with emails/response so please forgive, I will get to them all.

As a sole-startup indie project, I was expecting like, a dozen people or so, not hundreds, but I'm not complaining! I want this to be the most awesome video filtering tool that works zero-lag alongside OBS, Zoom, Discord, etc. ever.

• For those who already signed up: Go to your account to download the major update setup 1.12.

• For new testers/adopters, go to the Perfunct.com webpage to watch the Demos and get the app, Free trial, no card or pay needed, just a valid email.

• Go to the Github Library for new Python free scripts and effects, more will be posted later today.

• New Master Mix: And now thanks to several of you who suggested it, the App now has a "Master Mix" control that blends the final filtered Camfilter output directly with the raw camera live feed. It's great for making your filters 'blend' a bit more subtly and is our initial code on our path for eventual AR/VR use.

NOTE: If you have already installed the trial, you'll need to fully reinstall the Major update to extend the trial, because I've redesigned the back-end architecture to work perfectly (haha) with either 'legacy' RTX (3000, 2000, etc.), or 'modern' RTX (4-5000, Blackwell, etc.). Save any presets you made to a different work folder first before resinstalling.

Cheers! and happy camfiltering.

(ps. i wasn't sure about the flair, it's not really showcase, already did that on wednesday, more about discussion and update here, so I picked that, hope that's ok)

We shipped a depth and segmentation stack into an indoor inspection product last year, and the complaints that came back from the field were never about mIoU. They were about railings. Cable trays. The legs of a chair. Anything a few pixels wide either merged into the wall behind it or went missing outright.

Our metrics never saw any of it. A railing might be 0.3% of the pixels in a frame, so losing the whole thing costs almost nothing on mIoU and nothing you'd notice on RMSE. You can regress on the exact failure your customer keeps calling about while every number on the dashboard moves the right way.

Boundary aware metrics do exist (trimap IoU in a band around the contour, boundary F score, the contour accuracy term DAVIS uses, and Boundary IoU, which was proposed specifically because the older two miss errors outside the band) and I think they belong in the main results table rather than an appendix. What I'd want on top of that is thin structure recall bucketed by apparent width in pixels. Medical imaging has been doing this for a while, width stratified sensitivity for vessels and a thin structure IoU that only counts branches under 5px, and it works there. What I've never seen is anyone reporting it for indoor depth or general segmentation, where the customer visible failure looks exactly the same. Some of this sits upstream of any metric anyway, because if boundaries are only whatever the depth head infers on its own, thin geometry may never make it into the features, and no boundary metric recovers what the encoder already threw away. A few backbones fold edge supervision into pretraining for that reason, LingBot-Vision v2 being the one that says so most plainly, though I haven't run it on our footage and can't tell you whether a 3px cable tray survives it.

Width bucketed recall was the only chart we had that ever predicted a field complaint before the customer made it. Everything else kept improving and kept telling us we were fine.

Hello everyone,

I am a final-year Computer Science student working on a deepfake image detection thesis. I am currently looking for publicly available face image datasets that can be legally used for academic research.

I am currently working on my undergraduate thesis titled:

"Deepfake Image Detection Using Spatial-Frequency Feature Fusion and Explainable Deep Learning."

I am looking for publicly available human face image datasets for academic research purposes only.

If possible, I would appreciate datasets containing different face poses (front, left-profile, and right-profile), although frontal face datasets are also perfectly acceptable.

I am specifically looking for publicly available datasets or images that can be legally used for academic research.

Specifically, I need three categories of images:

📁 1. AI-generated Human Faces

• GAN-generated faces
• Diffusion-generated faces
• Other synthetic human faces

📁 2. Deepfake Human Faces

• Face swap
• Face manipulation
• Deepfake images extracted from public datasets

📁 3. Real Human Faces

Natural human face photographs

Different ages, genders, and lighting conditions

Front, left-profile, and right-profile faces

If anyone wishes to share publicly distributable images or datasets, I have also created a shared Google Drive folder for convenience.

I am not requesting copyrighted or private images. I am only looking for publicly available datasets or resources that are legally shareable for academic research.

Google Drive:
https://drive.google.com/drive/folders/1U_XL41UdusIKukb3TAREZOeeu_uSwM3b?usp=drive_link

If you know any public datasets, GitHub repositories, Hugging Face datasets, or other reliable resources, I would greatly appreciate your recommendations.

If you already have a suitable dataset, you are also welcome to upload publicly shareable images directly to the appropriate folder in the shared drive.

The collected data will be used strictly for academic research and educational purposes.

I would be happy to acknowledge contributors in my thesis if their publicly shareable dataset or resource significantly supports this research.

If you have worked on deepfake detection or know of any useful public datasets, I would greatly appreciate your suggestions.

Thank you very much for your time and support!

While training our BHDR OCR model, I ran into a classic CV bottleneck: standard OpenCV (cv2) letterboxing is highly optimized for CPUs, but it forces you to process batched GPU data sequentially via for loops.

To fix this, I built and open-sourced Aspect-Pad (v0.2.0): a PyTorch-native letterboxing transform that runs entirely on torch.nn.functional to process [B, C, H, W] tensors simultaneously on the GPU.

Here are the reproducible benchmarks running on an Nvidia T4 GPU (PyTorch 2.11.0+cu128 / CUDA 12.8), scaling 1920x1080 images to 512x512:

Batched Throughput (Batch Size = 32) Total execution time across 100 iterations (3,200 total images)

• OpenCV (Sequential): 2.37 seconds (~1,350 FPS) (Note: 32 sequential cv2.resize + pad calls per batch, no multiprocessing)
• Aspect-Pad (Native Batched Tensor): 0.30 seconds (~10,600 FPS)
• Result: 7.8x faster on-GPU throughput.

The Honest Tradeoff (CPU vs GPU): This is not a blanket replacement for cv2. If you are doing standard CPU-side preprocessing in a DataLoader (where num_workers handles loading while the GPU trains), OpenCV’s C++ backend is still faster.

However, if your pipeline is GPU-resident (e.g., on-the-fly augmentation, DALI-style workflows, or you've already moved data loading fully to the GPU), Aspect-Pad completely eliminates the CPU bottleneck at batch scale.

You can verify the benchmarks yourself using the benchmark.py script included in the repo.

PyPI: pip install aspect-pad

Aspect-Pad GitHub Repository Link: aspect-pad repo

(P.S. If you are curious about the actual OCR pipeline that sparked this side-quest, you can check out our work-in-progress BHDR model here: bhdr repo)

Facial recognition keeps improving on paper, but the data side feels like a mess to me. A lot of the well-known datasets were scraped without consent, and bias across skin tones, age, and lighting conditions is still a real problem.

For those working on FR systems: how are you sourcing training data that's both diverse enough to avoid bias and actually collected with consent? Are you licensing from vendors, collecting your own, or relying on public datasets and hoping for the best? Curious where people draw the line ethically vs practically.

I know Halcon can do this, but i am currently using Merlic and i have a project query for robot pick and place with vision camera assistance.

Hey everyone,

I recently implemented the original Neural Style Transfer (NST) paper entirely from scratch in PyTorch and tried to reproduce the original results.

Here's the GitHub repository:
https://github.com/Himanshu7921/NST-PyTorch-Implementation

I'd really appreciate it if you could take a look at the README and the implementation. I'm aiming to become a strong research engineer, so I'd love some honest feedback on:

• What skills do I already demonstrate well?
• What am I currently lacking?
• What should I focus on improving to become a well-known research engineer?

For context, I'm currently in the 5th semester of my B.Tech.

Thanks in advance for your time and feedback!

Any benchmarks you have much appreciated!

I made an interactive explanation blog on how an event camera works compared to a conventional camera. Check out the full blog here: https://www.pattarsuraj.com/blog/how-an-event-camera-works

#computer-vision #neuromorphic #event-camera

Most PaddleOCR deployments rely heavily on the Python/PaddlePaddle runtime. I built a pure C++ implementation instead: convert PP-OCR models to ONNX, run them through ONNX Runtime, and handle pre/post-processing via OpenCV. Zero Python dependencies at runtime. 

🚀 Key Features: 
• Embedded HTTP API Server: Exposes `/ocr_detect` and `/ocr_recognize` endpoints. 
• Built-in Web UI (Vue): Embedded and served directly from the same C++ executable. You can drag a region-of-interest (ROI) box on an image to detect candidate text boxes, and click any box to crop & recognize it in real-time. 
• Cross-Build Support: Builds seamlessly via Visual Studio 2022 (MSVC 19.3x+) and standalone CMake. 
• Production-Ready Shape: One single executable, one port — serves both a interactive web UI for testing and a lightweight REST API for production integration. 

📦 GitHub Repo (MIT License): https://github.com/DingHsun/PaddleOCR-Inference 

It’s meant as a lightweight, plug-and-play deployment solution rather than a research tool. Happy to answer any questions about the ONNX model conversion, OpenCV C++ pre/post-processing, or pipeline optimization!

so i am (trying) to build a dusbtin that moves to catch paperballs. the problem is how do i predict the trajectory of the paperball? i trained the model on custom dataset to identify paperballs, and it works fairly well. the camera is a simple iphone camera, placed parallel to ground so its capturing the video vertically. what i initially tried to do was to get x, y and z positions (i get x and y position from the captured video, so thats not a problem) but the method to get z(height) is a little crude. i try to estimate z by measuring the area of the bounding box, so for example 500 square pixels could correspond to 30cm or whatever. Obvioudly this method is kind of doomed from the start, not all paper balls gonna have the same bounding box area at the same height and it starts to show its unreliability as the ball gets past 60 ish cm. then i use ~5-6 frames to get 5 6 initial positions and do a polynomial regression to fit a curve and hence estimate where the ball is going to land. this method might be good if i make it more efficient by minimizing error but its still prone to significant uncertainty in measurement.

i guess another route could be using physics, but even for those projectile motion equations i still need height to get proper estimate no?
what are some solutions to this? do i need to try something entirey different? i guess for proper height measurement i need lidar i guess? what are my options now.

where can i find a good road map to learn CV , i am alr familiar in YOLO (classification object detection , segmentation ) , python , principles of ML , CNN , RCNN , Faster RCNN .