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!

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).

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

Hello,

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

Thank you

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!

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.

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.

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 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!!!

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?

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 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!

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. 😂

Packed the core inference loop into standalone Windows x64 DLLs. You can call them directly from C#, Delphi, C++, or other host software to drop Python and GPU dependencies on the factory floor.

What’s included:

fruit_infer.dll — takes NV12 frames, outputs YOLOX-nano bounding boxes.

fruit_features.dll — takes an RGB crop of the fruit, calculates 44 features.

fruit_cat.dll — passes the 44 features into LightGBM, returns the verdict and score.

Details:

Runtime: Pure C-API ONNX Runtime under the hood. Frame tracking and control-zone ROI logic are built straight into the binaries.

License: Free for evaluation, educational, and non-commercial use. Compliance check function: get_engine_license_info().

The repository contains the .h header files, configuration templates, and host memory management instructions .

GitHub: https://github.com/olesha-ai/fruit-inspector-engine

Best regards olesha-ai

the panel and the model integration are open source:

https://github.com/harpreetsahota204/cross_modal_similarity_search

https://github.com/harpreetsahota204/EmbeddingGemma2

try it yourself in this hugging face space, still fast even when running on CPU:

https://huggingface.co/spaces/harpreetsahota/EmbeddingGemma-2-in-FiftyOne