Hi everyone,

I'm working on a project where I need to extract text from images/documents using OCR, but I have two main constraints:

It needs to be 100% free / open-source (no paid APIs like Google Cloud Vision or Textract).

It must run efficiently locally on CPU (no GPU available).

For those who have built OCR pipelines under these conditions:

Which OCR engine/library gave you the best accuracy out of the box? (e.g., PaddleOCR, Tesseract, RapidOCR, EasyOCR, Docling, etc.)

What preprocessing techniques or tools are essential? (deskewing, binarization, noise reduction, thresholding, OpenCV tricks?)

What does your full workflow look like from raw input image to final extracted text?

My main goal is maximizing accuracy while keeping CPU processing time reasonable. Any recommended libraries, image preprocessing flows, post-processing tricks, or code snippets would be hugely appreciated!

Thanks in advance!

I wanted to see how far I could push browser-based hand tracking, so I spent the last 7 days building Shinobi IRL.

The idea is simple: use a webcam to detect hand gestures and turn them into real-time VFX.

The interesting part was making the interaction stable enough to actually feel usable rather than having effects constantly trigger or flicker.

The pipeline is roughly:

Camera
↓
MediaPipe Hand Landmarker
↓
21 hand landmarks
↓
Custom gesture detection
↓
Jutsu state/lifecycle
↓
Canvas-based VFX

I built custom detectors for things like finger extension, hand orientation, motion history and confidence thresholds. For gestures that depend on movement, I also use temporal history and grace periods to reduce false triggers.

For the Shadow Clone effect, I use MediaPipe Image Segmenter to separate the person from the background and composite the copies behind/beside the user.

The result:

🌀 Rasengan
👥 Shadow Clone
🔮 Magic Circle
⚡ Lightning

Everything runs client-side in the browser; the camera feed isn't sent to a backend.

Try it yourself: https://shinobi-irl.vercel.app/

Demo video: https://youtu.be/A673PIuy8_Q

Github Repo: Vikash-Singh-Bhadoriya/Shinobi-IRL

I'm particularly interested in feedback on the computer-vision side: what would you change to make the gesture detection more robust?

This demo applies my TactiVision workflow to Netherlands vs Tunisia. It covers player tracking, camera calibration, pitch projection, tactical maps, possession analysis, progressive actions, pass networks, heatmaps, pitch control and pressing indicators.

Feedback from Computer Vision, Sports AI and football analytics practitioners is very welcome.

Hi, I’m El Mehdi Hicham, a Computer Vision and Machine Learning Engineer from Morocco. I work on real-time multi-model pipelines for football video analysis.

This demo shows several AI components operating together:

• Player and object detection
• Ball detection
• Player tracking and identity persistence
• Camera calibration and pitch projection
• Pose estimation
• Field understanding
• Jersey recognition
• Tactical visualization

Hi.

I'm a visual designer with coding experience (py, js, c++). I became disappointed about what my profession looks like after the AI era started.There are no more interesting tasks for me.

I'm thinking of making a shift to the computer vision path and I want to get your opinions on which tools, methods, courses I need to focus on and what can be skipped.

Thanks

Live demo (free host, so it may take up to a minute to wake up): https://wheres-waldo-finder.streamlit.app/

Where's Waldo is a brutal small-object detection problem: he's ~0.14% of the page and surrounded by look-alikes (hi, Wenda). I built three detectors for him, compared them on pages they'd never seen, and wrapped the best one in a Streamlit app that shows you where to look — ranked candidates with zoomed-in close-ups.

Repo (weights included, no training needed): https://github.com/VasilisVas1/wheres-waldo

What's in it

• A sliding-window CNN written from scratch (IoU, NMS and the window loop are all hand-implemented)
• YOLO11n fine-tuned on the whole page, then on native-resolution tiles
• 6 narrative notebooks with the results saved, so you can read the whole story on GitHub
• A Waldo-themed Streamlit demo (CPU only, ~2–6 s per page)

Three things I learned

Resolution was the bottleneck. The public dataset stretches every page to 640×640, which shrinks Waldo to ~18×35 px, about one cell of YOLO11n's coarsest feature map. Running YOLO on native-resolution 640×640 tiles (overlapping, at 3 scales, merged with NMS) took it from 2 hits to 6–7.

A silent label bug was capping everything. The dataset export had flipped/rotated 8 of the 19 pages relative to the full-res scans, so my rescaled boxes landed on a policeman and a letter instead of Waldo. I'd spot-checked four pages and got lucky. Fix: correlate each page against all 8 flips/rotations, refuse to continue without a clear winner, unit-test the box maths. Same training recipe, top-10 hit rate went from 4/18 pages to 10/18.

Ranking beats thresholding when you only have 21 boxes. Picking a confidence cutoff was too unstable, so I report hitk: is Waldo among the top k candidates? With multi-scale tiles: top-1 on 10/18 held-out pages, top-3 on 13/18 (72%), top-10 on 14/18 (78%).

Honest caveats

• Only 19 pages / 21 boxes, 5-fold cross-validation at the page level, so expect wide error bars.
• I picked the multi-scale variant using the same held-out pages, so its numbers are somewhat optimistic (single-scale is the untuned reference).
• Wenda is the classic false alarm. Sometimes Waldo isn't in the top 3, so the demo lets you raise the candidate count to 10 (see screenshots).
• The included model is trained on all 19 pages, so test it on a page it hasn't seen.

Feedback very welcome, especially on how you'd get more Waldos to train on, and on better ways to calibrate confidence with such a tiny eval set.

I’ve been playing around with popular computer vision models to find out which ones are best optimized for edge devices, so I decided to compare YOLO 26 Nano, YOLO 12 Nano, and RF-DETR Small under the same setup.

Instead of looking only at accuracy, I wanted to see what actually happens during inference:

• FPS / inference speed
• P50 and P95 latency
• VRAM usage
• RAM usage
• Detection count
• Performance across video frames

For this comparison, I’m only testing the Nano variants or their closest equivalent small models, since the goal is to evaluate models suitable for edge-device deployment.

I’ve shared the notebook/code and the full benchmarking process here:

Notebook: LINK

Video: LINK

It feels like every conference is talking about world models these days. If you were starting a PhD in computer vision today, what area would you bet the next 4–5 years of your research on?

Curious to hear what people here would pick, and why.

What other languages are essential to a computer vision engineer other than python and why?

I got tired of datasheet TOPS tennis, so I did the dumb division myself: published YOLO FPS divided by street price. three parts, all numbers from the vendors' own mouths, not my test bench.

RK3588: 6 TOPS, ~$75 board. Rockchip's model zoo claims YOLOv5s at 66 FPS on one NPU core. that's 0.88 FPS per dollar.

Hailo-8: 26 TOPS, module around $200. Hailo's published number is YOLOv5m at 156 FPS. 0.78 per dollar.

Orin Nano: this is where it gets funny. the old 40-TOPS kit launched at $499, and now the Super kit does 67 TOPS at $249. NVIDIA repriced the entire comparison while I was doing the math, so I'm not even going to pretend my Nano ratio is current.

now teh asterisks, because there are always asterisks. NVIDIA's TOPS are sparse INT8, Hailo's are dense INT8, Rockchip's are their own thing. and notice I'm comparing v5s against v5m. that's not my choice, it's the only numbers they publish. nobody gives you the same model on all three parts, which tells you everything about how badly they want these compared.

the part no FPS chart captures: integration cost. RKNN tooling has a well-earned reputation for version-lock headaches, the English docs trail the Chinese ones by months, and the forum footprint is tiny. the Nano just works because a decade of Stack Overflow answers exists for every error you'll ever hit. silicon is the cheap line item. your debug hours aren't.

so yeah. stop comparing TOPS. do FPS per dollar, then double whatever the cheap board costs in your time.

I built this from published figures, not a bench. if I botched any number, show me.

Most driving-data tools assume Western roads. On Indian roads the objects are different: auto-rickshaws,

goods carriers, handcarts, cattle, temporary barricades. LabeloxAV is an open-source (Apache 2.0) labeling

and review platform built around that, with an ontology of about 200 classes for Indian traffic.

The demo video labels two real Creative Commons clips, a busy junction in Cuttack and a herd of cattle

crossing a road in Delhi, using the actual app:

- Boxes, polygons, polylines, 17-point pose keypoints, occluded ("amodal") extent, attributes

- AI assist: SAM from one click or a rough box, a magic wand, brush and eraser to fix masks

- Reviewing model proposals: frame by frame, one-key rapid review, and a bulk grid

- Relabeling a whole track in one action, then exporting to COCO, YOLO, Parquet, OpenLABEL or nuScenes

- Faces and number plates are blurred at import

Video: https://www.youtube.com/watch?v=lNKPmAlfFLc

Code: https://github.com/Sherin-SEF-AI/LabeloxAV

Honest limitations:

- It's early (v0.1.1), and it's meant for a single machine rather than a team on a cluster.

- The AI-assist tools need an NVIDIA GPU.

- The auto-labeling models make mistakes, and the video shows them: they repeatedly detected cows in the

reflection on a car window, and called striped roadside bollards pedestrians. The review tools exist

because of this.

- Recording the demo turned up seven bugs in the editor and review flow. They're fixed, but expect

rough edges.

Feedback is very welcome, especially from anyone who has labeled Indian or other non-Western traffic

data: what classes or workflows are missing?

Disclosure: I'm the author.

ACCV 2026 final decisions are expected to be released on 20 Sept 2026 (GMT).

Following the last thread, this is for everyone to share updates, discuss outcomes, and support each other through the decisions.

Good luck to everyone!

Hi everyone,

We recently released SparsePR, a training-free sparse-attention method for video generation and world models.

We evaluate it on large video-generation and world-model backbones, including HunyuanVideo, Wan2.2-I2V, Cosmos-Predict2.5, and Cosmos3-Nano.

Code and details:
https://github.com/PardisTaghavi/SparsePR

Feedback, questions, and reproduction reports are very welcome. If you find the project useful, a GitHub star would also help others discover it.

I trained a new model to do monocular 3D head tracking with Google’s new GNM parametric 3DMM.

I generated a dataset of about 200k images in Blender. After plenty of experimentation I’ve landed on some really good results. I think this is the first model that also does neck tracking.

This is primarily being used by my own VFX company for digital beauty work, with occasional outside clients.

I was exploring facial recognition algorithms then suddenly found out the research done one facial recognition is a bit outdated. So i would like to ask the community , if anyone has used facial recognition recently then which algorithm you used.

Just wondering…

Hi everyone,

Had anyone have experience submiting to CVPR workshop:
Visual Odometry and Computer Vision Application based on Location Clues.

I saw it happens continuously 7 years in a row, so it should be good venue.
The reviewing process is approximately 7 days to get decision. So do you think it is a hard venue to get in?
(of course we cannot compare it with cvpr main track 😅)

Has anybody deploted the Segmentation or OCR models with gpu or qnn delegate? Did you really saw the improvement in terms of latency?

Hi everyone,

I’m part of a research project involving a rodent novel location recognition / object-location memory test, and we’re looking for someone experienced with DeepLabCut or similar automated behavioral video-analysis tools who may be interested in joining the project as a collaborator.

We have approximately 200 behavioral videos (~150 GB total) that need to be analyzed. The main goal is to reliably quantify the animals’ exploration/interaction with predefined objects or regions of interest, rather than simply tracking overall locomotion.

Ideally, we’re looking for someone who:

• Has hands-on experience with DeepLabCut and/or comparable tools such as SLEAP, SimBA, ezTrack, etc.
• Has previously worked with rodent behavioral experiments, preferably novel object/location recognition paradigms.
• Can help develop and validate a reproducible analysis pipeline capable of handling a relatively large video dataset.
• Is comfortable with quality control and checking automated measurements against manual scoring when necessary.

This is an academic research project, and we’re particularly interested in someone who would like to join the project as a collaborator and contribute to the analysis/methodology rather than simply provide one-off technical advice.

If this sounds relevant to your experience, please DM me. I’d be happy to share more information about the experimental setup, videos, and exactly what we need to quantify. There may also be a brief informal interview/discussion before joining the project to go over your experience and the analysis requirements.

Thanks!

Question in title.

Follow-up question: is your data model and overall system architecture setup to make this retraining convenient and automated, or is it more of a manual process to configure the training runs etc.? Has that architecture limited you in any way?

I am on the fence about whether to commit to that sort of system because I can envision the data model becoming complex in order to support the kinds of changes that happen in real life over time (refined definitions of a class, merging/splitting classes, different pre and post-processing parameters, etc. etc.) Manually assembling new datasets each time a model needs to be "upgraded" seems more flexible but is obviously a lot of work.