We’ve been working on mapping points in surveillance footage to geographic coordinates. In this demo, clicking a point in the video shows its corresponding location in a 3D scene.

The approach is purely vision-based and requires no additional hardware. We’re exploring how it could support location reconstruction, trajectory tracking, and analysis of camera coverage gaps.

I’d be interested to hear from anyone working on similar image-to-world mapping problems.

I'm a fresher aiming for computer vision and ML engineer roles. I finished a project and I'd like honest feedback on whether it's interview-worthy or not.

What it does: detects 6 kitchenware classes (plate, spoon, fork, knife, cup, glass) in live camera video on an Android phone, fully on-device.

What I did:

- Data (9,400+ images, ~6.5-7 hours total): I labeled it semi-automatically, not by hand-drawing every box.

1. Ran Grounding DINO on 900 images (150 per class) to generate bounding boxes, then checked and corrected them by eye.

2. Trained a seed YOLO model on those 900 images and used it to label the remaining images.

3. Reviewed those labels by eye for missed or wrong boxes, and did the corrections in X-AnyLabeling.

4. Published the dataset on Kaggle: https://www.kaggle.com/datasets/raunakgola/kitchenware-object-detection-dataset-yolo-format

- Model selection with Optuna: 25 trials, max 15 epochs each, maximizing mAP50-95. Search space:

- model: yolo26n/s, yolo12n/s, yolo11n/s, yolov9t/s, yolov8n/s (10 candidates)

- lr0: 1e-4 to 1e-2 (log scale)

- batch size: 8, 16 or 32 (capped for 24 GB VRAM)

- mosaic: 0.0 to 1.0

- Training: fine-tuned the two models I picked, YOLO26n and YOLO26s, on the full dataset.

- Compute: a RunPod RTX 4090 pod. Optuna, both training runs and the model conversion took about 5 hours in total and cost about $4.5. It saved me a lot of waiting compared with Google Colab.

- Export + quantization: exported to LiteRT and compared formats. Static INT8 was rejected. I went with 8-bit weights and float32 activations (w8a32): mAP50-95 0.9406 at 2.72 MB.

- App: Kotlin app with CameraX and LiteRT, GPU first with CPU fallback. It filters by class, has confidence/IoU sliders, and shows live FPS, latency and RAM. On my one test phone it ran about 10-14 FPS on GPU and about 4-5 FPS on CPU (single readings, not a proper benchmark).

Being upfront: I generated the Android app with an AI coding agent (Claude Code). I directed it and tested it, but I didn't hand-write the Kotlin. The ML side (data, Optuna, training, quantization decision) is my work.

Known weaknesses:

- The 0.94 mAP is on my validation split, not a separate real-world test set.

- The labels (train and val) came from the same semi-automatic pipeline, so the score partly reflects label consistency.

- It misses some objects and sometimes confuses fork and spoon.

- I tested on one phone only.

Repo: https://github.com/raunakgola/Wareye

My questions:

1. Is this strong enough to help in interviews, or does the AI-built app hurt it?

2. What would you add or fix first: a held-out real-world test set, error analysis, something else?

3. Would you rather see more depth on the model side or a hand-written app?

Thanks for any honest feedback.

Hey everyone! Previously, I built a 5-servo robotic hand controlled via computer vision. Instead of modifying the old setup, I decided to build a completely new robotic hand from the ground up.

This new version steps up to 6 servo motors to get much more complete, fluid hand movement.

How it works:

• Real-time Tracking: Using Python, OpenCV, and MediaPipe on the laptop to track hand landmarks live.
• The Hardware: Wired up 6 servos acting as tendons to control the fingers and the extra axis of movement.
• The Test: Putting the new frame and wiring through its paces to check gesture mirroring and response time.

Still working on refining the code and handling power distribution for all 6 motors. Would love to hear your thoughts or any tips you have for multi-servo setups!

The approach followed:

- YOLO11n-pose gives 17 keypoints. Keypoints 0-4 (nose, eyes, ears) give the head centre.

- Box size comes from ear-to-ear distance, eye distance x 3.2, or shoulder width x 0.6, whichever is most reliable that frame.

- If the person is facing away (no face keypoints), fall back to the top ~22% of their body box.

- Pixelate an oval on a worker thread, encode the JPEG, then restore the sharp pixels for the local preview.

- Boxes older than 0.6 s are dropped, so it never blurs the wrong spot. Costs ~3 µs on the main thread and ~50-100 µs per frame on the encoder thread, with zero GPU cost.

Where it can fail: heavy occlusion and very small/far faces.

Hello! I am new here and basically wanted to know if someone can recommend any cost-effective development board for embedded solution? Basically an embedded board that can be programmed for edge usages, and allow adding sensors like camera.

We continued pre-training kha-white's mangaOCR (same architecture, new vocabulary) on the training data of manga-ocr-nar-small, and released two models:

- manga-ocr-base-CPT (224×224, same input as the original): https://huggingface.co/muscgab/manga-ocr-base-CPT

- manga-ocr-base-CPT-flex (aspect ratio kept): https://huggingface.co/muscgab/manga-ocr-base-CPT-flex

JMangaBench_Read v1.3, 7,789 boxes, exact match: original mangaOCR 81.29% (greedy) → CPT 91.00% → CPT-flex 91.42%.

With greedy decoding and CUDA graphs it takes about 11 ms per box at batch 1 on an RTX 2080 Ti (original package: 84.9 ms). The repo also has inference scripts that make Hayai v2.5 Nova and PaddleOCR-VL-For-Manga about 2.6× faster at batch 1, with identical outputs.

Code and technical report: https://github.com/muscgab/manga-ocr-CPT

Caveats: the benchmark is ours (tight text-block crops from AnimeText YOLO12x detector, mostly web-published manga).

Hello,

My supervisor is pulling a don draper so any insight/opinion is welcome!!

Thank you

A candidate has a technical interview in a few days for an MLE internship on TikTok's data search/visual search team. How would you divide the remaining prep time?

The immediate question is how much to spend on coding versus ML fundamentals and search/computer vision concepts. Intern-level advice would be especially useful: which ideas should a candidate be able to explain clearly, and what kinds of practice helped connect the theory to an actual interview discussion?

TikTok Interview Questions can help organize company-specific practice, though the team and role still matter when choosing prompts. If other internship applications are eating into the remaining days, application autofill and Agent autoapply can reduce the repetitive admin.

If you've interviewed with this team or a similar one, what was worth reviewing? What would you leave out when time is this short?

Disclosure: I operate PracHub and LandOffer.

Hey all. I've been working on table extraction from PDFs without any deep learning, and finally open-sourced it. Thought this sub might find the approach interesting (or tear it apart, which is also useful).

The pipeline, roughly:

- Bordered tables: morphological opening with long horizontal/vertical kernels to isolate ruling lines, then contour analysis on the line mask to find table regions.

- Borderless tables: detected from text alignment instead. Words are grouped into phrases and checked for left/centre/right alignment across consecutive lines. When enough rows and columns line up, I draw "pseudo-boundaries" onto the image so the rest of the pipeline treats it like a bordered table.

- Structure: text is masked out first, then LSD (Line Segment Detector) finds segments, which are clustered and merged into a grid. A spanning cell is recovered from missing line segments: if a separator is absent across part of the grid, those cells merge (union-find over the cells).

- Text: for digital PDFs, characters come straight from the PDF text layer and are mapped onto the cell grid, so there are no OCR errors on part numbers. OCR (Tesseract or a plugin engine) only runs on scanned pages.

- Post-processing: nested header detection, key-value vs normal table classification, and merging tables that continue across pages (by matching column widths and headers).

Everything runs on CPU, roughly 0.3–1.5 s/page on a laptop, and every decision traces back to a threshold you can inspect. All pixel thresholds are defined at 300 DPI and scale with resolution.

Where it struggles:

- skewed scans (no de-skewing yet; the line detector only tolerates ~2 px of drift)

- small borderless blocks where a header row can be mistaken for key-value pairs

- wrapped text in borderless cells sometimes splits into extra rows

Contributions very welcome. MIT licensed, no need to ask first, just fork and PR. Some things I'd love help with:

- de-skew estimation (Hough/projection-based) before detection

- evaluating on ICDAR 2013 / PubTables-1M / FinTabNet with GriTS or TEDS; I don't have a proper benchmark yet, and that's the biggest gap

- better row reconstruction for borderless tables with wrapped cells

- plugging in other OCR engines (there's a plugin interface + EasyOCR example)

Repo: https://github.com/shlok-n/spartan · pip install spartan-tables

Hi, does anyone know if the format and submission portal for the BMVC 2026 poster and video are opened? I haven't found any information on the official website like last year, but the deadline is October 30 in the schedule.

Hi everyone,

I'm developing an Android application that uses the phone's camera to detect objects in real time. I'm looking for recommendations for the best pretrained object detection model that can recognize a very large custom vocabulary without requiring me to train or fine-tune a model initially.

My requirements

• Vocabulary: Approximately 3,250 labels covering everyday objects, animals, appliances, electronics, kitchenware, clothing, food, drinks, and more.
• Important food classes: Indian dishes such as baingan bharta, aloo gobi, biryani, butter chicken, chole bhature, dal makhani, dosa, pav bhaji, and others.
• Detection output: Object names, confidence scores, and bounding boxes.
• Preferred deployment: On-device inference using TensorFlow Lite or another Android-compatible runtime, ideally offline.
• Training: I want to avoid training or fine-tuning if an existing pretrained model can meet these requirements. Fine-tuning is my fallback option.

I already have a vocabulary file in the format name<TAB>category, with optional text prompts for acronyms. However, I understand that adding a label to a vocabulary does not guarantee that the model can recognize that object accurately.

Questions

1. Which pretrained open-vocabulary object detector would you recommend for this use case?
2. Can models such as YOLO-World, Grounding DINO, YOLOE, or another newer model handle thousands of custom labels?
3. Can any of these models reliably recognize specific Indian dishes such as baingan bharta without fine-tuning?
4. Is there a practical way to deploy the recommended model on Android with real-time camera inference?
5. Would you recommend one general-purpose detector or combining a general object detector with a food-recognition model?

I'd appreciate recommendations based on actual model capabilities, deployment experience, and accuracy rather than just the number of supported labels.

Thanks!

Hello there, I’m Suva from Hugging Face 🤗 and I'm back with something new around 3D and LLMs!

LLM 3D Worlds Arena - a Hugging Face Space

We've been seeing an explosion of 3D worlds being generated by LLMs, so we made an arena where you can move around and rank 650+ 3d worlds generated by multiple different LLMs like GPT 6-Astra, Claude Opus 5.5, Kimi K3, and many more. Choose the best model of them all. Go and vote now!

Would love to hear what models you folks would like to see next!

I’m facing issues regarding integration CP Plus based DVR with my system remotely since I’m not connected to the same local network and local ip won’t work. I want to access it via RTSP URL

Three weeks ago I started reproducing a fine-grained classification paper from 2024, we are going to build on it at work if it holds up. The results table in the paper says 87.3. I could not get my runs past about 85.8 and most of the next two weeks went into the learning rate and after that into augmentation strength. Then I ran their released checkpoint through their eval script on our training box, which I should have done on day one, and it got 85.9, basically what I was getting. That machine is shared with other teams, it is still on PyTorch 2.1 and torchvision 0.16 and nobody wants to touch it.

So I tried the same checkpoint in a fresh PyTorch notebook on HyperAI, and installing their repo and uploading the checkpoint and the test split took longer than the eval did. It gave 87.2 there. I diffed pip freeze between the two machines and spent an evening going down it line by line before I got to torchvision.

Their repo loads images with read_image, which gives you tensors, and Resize is called without antialias. On torchvision 0.16 that means tensors get resized with no antialiasing at all, it only became the default in 0.17. The warning about this is the first line of every eval log I have. Their requirements.txt says torchvision>=0.15, which our box meets, and I do not get why anyone puts a >= on a paper repo they expect people to reproduce.

With antialias=True their checkpoint matches on our box, but my runs were all trained on the aliased images, so they need redoing and with our queue it will be next week before I know how much of my gap this was.

I am new to computer vision and I am trying to make a pipeline which can predict if a hospital beds rail is up or down , The bed looks somewhat like the image attached , What I currently have
- A live stream from my camera
- A 3d simulation enviornment mimicing the bed closely
- A finetuned Model which gives me bed segment mask
- A finetuned model giving me bbox of rails
considering the wide variety of positions of camera and camera angles and occlusion
Is this a 2d spatial problem which is almost unsolvable with current landscape ?

I gave Gemini 4 Argon cameras, LiDAR and code access to a RealMan ECO65 in a MuJoCo twin of my desk. The task was to throw a 40 mm foam ball through a 90 mm rim, 85 cm away. No training for this task. It could inspect the sensor views and write code for the arm, but did not receive the ball coordinates or the simulator's hidden score.

In the final run it took five throws and roughly 26 minutes of thinking. The simulator counted four makes. Gemini counted three.

The interesting bit for vision is throw two: the ball hits the back rim and drops through, but Gemini reports that it landed significantly short. This replay shows the actual saved simulation trajectory.

My working explanation is the overhead view plus our purely visual net: the ball can drop straight through and look like a short miss from above. I have not isolated that with an ablation yet.

Before this run, we also had a wrong table, an unstable sim and a gripper squeezing the ball out. Those were our setup bugs. All the throwing shown here is simulated; the physical arm has not done this. Five throws in a fixed scene are a small test.

I put the full experiment, failures and score comparison in my EP11 build diary: https://www.youtube.com/watch?v=ujDq_-c1gm0

For people evaluating vision-based robot feedback: how would you verify a brief event like this without giving the model the simulator's ground truth?

Exploring ocean plankton data just got a lot easier thanks to MBARI’s FathomNet and Voxel51 - https://voxel51.com/blog/fathomnet-plankton-fiftyone

This tutorial shows you how to load FathomNet’s expertly-labeled plankton imagery into FiftyOne and put CLIP to work on it.

• FathomNet: an open-source ocean image database from MBARI & collaborators, ~84K images and 2,244+ concepts at launch
• Loaded 200 plankton crops across 18 taxa using the fathomnet Python client * CLIP embeddings in 2D show morphologically similar species clustering together
• Zero-shot classification with CLIP — no training required * Clickable confusion matrix to inspect exactly where the model confuses taxa
• Uniqueness scoring flags near-duplicate crops before training
• All runs on a laptop, in a single Jupyter notebook.

Learn more about the FathomNet Program: www.fathomnet.org

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 folks, I've posted here about this before, and lots of you asked if I could make an AMD version. So a month of work (was tricky! i have not slept much), I now have an AMD version! Beta 1.22 ready to go. I hope to find testers using RDNA 2-4, to see if it works decently.

I made an announcement of the new Beta 1.22, and install demo/tutorial video. Because this is a whole new GUI and optimizations, if you've already installed (great!) you'll need to do a 'clean' install (backup is saved) that also first runs the new automated web-camera diagnostic tool.

My PC app enables live video (webcam or procam) 'filtering' to greatly improve low light and high-clutter RVM background segmentation/removal, is optimized for GPU speed, and includes on-the-fly insertion of Python scripts, via my custom Node Editor with openCV and onnx and mediapipe lots of other libraries available. You can do anything to make 'special effects'. I made a bunch of simple example/template scripts that are included upon install (camfiltergpu.com).

I think it's a great tool for experimentation and education, and next is to get some libre YOLO and such in there. I would much appreciate if anyone has suggestions. My app is geared more towards presenters and fast/live experimental video-processing work, but I think I have a powerful framework setup here where I can rapidly make code GUI changes and improvements for scientific, statistically quantifiable work. I've already got a microscopy version in the works.

My biggest problem right now is that I only have older laptop GPUs (nvid 2080, 3060, and amd 680M), so I basically have no idea if it will work on more modern Gpu cards, so maybe some of you could help.

Well, hope you-all find this at least interesting. I'm not an AI by the way, just an indie coder. Cheers!

(edit) you can see more info and download the installer at camfiltergpu.com. Note it might get flagged as 'virus'. There are absolutely no viruses or anything like that. Downloading only requests an email, no payment needed for the trial (fully capable) version.

Hello everyone.

First of all I say that I am a complete beginner to Computer Vision and I know I may not be giving enough context/information. If more information is needed, don't hesitate to ask.

I am currently developing a calibration station for hydrometers. I want the process to be semi-automatic, and for that I need an algorithm that is able to recognize when the water meniscus aligns with the selected mark.

To keep things brief and relevant, I won't specify the whole process, but here's a piece of the workflow:

The calibration station consists of a platform which moves a container up or down to achieve alignment of the water surface with the desired hydrometer mark and an independent motor that controls the camera vertical position.

The user selects a set of marks to be calibrated by aligning the camera's horizontal centerline to each mark. The software saves the positions of each one. By selecting one of the saved marks, the user can tell the motors to automatically align the meniscus to that mark.

My issue lies in that I am not able to detect the meniscus reliably.

I'd share my pipeline, but I experimented with some generated edge-detection scripts, but none were robust enough to handle the meniscus reflections consistently as I was frustrated and wanted to finish the project and as i took a pause from it I do not remember exactly what I was doing.

The camera setup is the following: the camera is slightly aimed downwards and there's LED lighting at the side of the container.

Here's an image of how everything looks through the camera.

Does anyone have an idea of how can I solve this issue?

Hey everyone!

I'm preparing for college placements, and most of my projects are around computer vision, egocentric perception, and robotics.

Looking for someone who can spare 20 minutes to take a mock technical interview and expose the gaps in my knowledge before the actual interviewer does.

Feel free to ask tough questions, roast my explanations, and point out where I'm bluffing without even realizing it.

Would really appreciate some honest feedback. Anyone interested, please DM me!

Thanks in advance. You might save one engineer from unemployment. 😂

I'm generating extra training data for a person detector by inpainting additional people into existing photos of crowded public spaces.

What I've tried so far:

• Pick a floor position and size the new person from a height-vs-y fit on the people already in the image.
• Mask a person-shaped region, excluding the pixels of people already there.
• Inpaint with FLUX.1-schnell (text prompt only, 4 steps).
• Re-segment the output and keep only regions where a person is actually detected.

Results: when a person does get generated, my detector treats it about the same as a real one. But only about 25% of medium-sized masks and 55% of large ones produce a recognisable person. The rest come out as smears or object-like blobs. Copy-pasting cut-out people from other images was worse, because they looked pasted (wrong lighting and viewing angle).

Next I plan to add a pose skeleton (OpenPose/DWPose ControlNet) and a body-silhouette mask, then compare FLUX Fill, Qwen-Image-Edit and SDXL + BrushNet.

Questions:

1. Which inpainting setup has given you the most reliable full-body person inside a mask?
2. Did pose conditioning or mask shape matter more?
3. Any settings that work for small people (40-120 px tall)?
4. How do you filter failed generations, apart from re-running a segmenter?

Hey folks, I’m building a computer vision product in-house and need help figuring out a few things on the last mile: getting our model to work live with CP Plus DVRs/NVRs. Looking for someone who knows IP cameras, networking and computer vision to point us in the right direction (RTSP/ONVIF access, network setup, stream stability).
Comment or DM if you've done this before. I’d really appreciate it. Thanks!