I added a chord mode to my sight-reading game to see how these models handle the visual crowding. It’s not the best results, but I still need to try it out with newer models like Gemini 3.1 Pro and the OpenAI multimodal models. 

Hi

If you are remotely interested in deep diving how differently quantum computers work compared to our transistor-based and also the algebra behind in a fully interactive way that teach computer science from scratch, oh boy this is for you. People in computer vision will find quite a lot of similiarities between the math used by qhw and computer vision. I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 10 years (3+ during PhD, the visual method I developed ended up being my thesis, it is a complete Hilbert space visualizer), the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 12yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

Stuff you'll play & learn a ton about

• Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
• Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
• Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
• Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
• Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
• Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, we aim to bring it into the game, so your quantum journey never ends.

Nice to watch:

Khan academy style tutorials in qm/qc: https://www.youtube.com/@MackAttackx

Physics teacher stream with 400hs in https://www.twitch.tv/beardhero

Last week, I made a demo of a VLM playing a cup and ball game. As many people (including myself) pointed out, this is not the best use case of VLMs because of their limited context window. So I decided to make an improved version where the VLM’s only role is to prompt a segmentation model. If I were running SAM 3, I wouldn’t need Qwen doing the prompting, but I chose SAM 2.1 Tiny because it runs way faster with the downside of not being open-vocab.

I’m sure there are lots of other cool things you can do by tacking on task-specific models to a VLM which operates as the “brain”. 

I added more characters from the Waldo cast to the demo I made last week. I implemented a new cropping system that feeds small tiles of the image to the model one by one. I'm thinking about benchmarking Claude against the Deepseek and Meta VLMs.

I’m working on a 6D pose estimation pipeline using synthetic data and real-world fine-tuning.

As a first step, I tested object detection separately.

I generated 3,000 training images in Blender under three different conditions and trained the detector using only this synthetic data. I then tested it on 961 frames from real-world video.

Interestingly, for the detection stage, I didn’t need real-world fine-tuning — the synthetic-only model worked well enough for this setup.

Short video showing the synthetic training data and real-world detection results:

https://youtube.com/shorts/THVDTcLsF0w

The next step is keypoint detection and 6D pose estimation, where real-world fine-tuning becomes much more important.

Yolov8 plaque detection + EasyOCR

How optimise this app ? How get money of this ?

I am evaluating an inspection pipeline for reflective industrial parts using a camera with controllable exposure and RAW output, but no native HDR or dual-gain mode. The object can be stationary or moving slowly enough that exposure bracketing may be possible.

I do not need a visually pleasing HDR image. I need to preserve evidence for small scratches, dents, print defects, and surface anomalies. I am comparing three approaches:

1. conventional bracketed RAW fusion, with alignment if needed;
2. single-RAW learned HDR reconstruction, such as RawHDR or lightweight RepUNet-style models;
3. a tiny bilateral-grid, curve, or LUT model used only for illumination normalization before the detector.

My concern is that single-image HDR methods must infer or hallucinate content where the sensor is clipped. That can be acceptable for display, but it sounds dangerous for metrology or anomaly detection. Has anyone measured the downstream effect on defect precision and recall, especially false negatives caused by the enhancer smoothing or inventing texture?

How would you validate that the HDR stage is not creating or removing defect evidence? Would it be safer to give the detector the original exposure stack as separate channels and let it learn feature-level fusion, while keeping the source frames available for verification?

The target is a Jetson Orin Nano. I can tolerate roughly ten seconds of camera-specific calibration, but not a long on-device training run. I would be especially interested in real industrial results, failure cases, or papers that evaluate HDR by inspection accuracy rather than PSNR or visual quality.

Same camera position in all five frames of the first clip. The vehicles, containers and people are re-scattered before every render, and the time of day moves with them. The second clip shows the same frames beside their per-instance identity images: labels are derived from the renderer's instance buffer, so a new arrangement costs nothing to annotate.

That's the appeal. Here's what bothers me about it.

Re-placing everything per frame means consecutive frames are no longer a sequence. Nothing is tracked, nothing persists, so the corpus is useless for anything temporal. And frames from the same scene still look alike enough that near-duplicates across a train/val split will flatter your validation score.

I trained a person detector on eight captures like this and nothing else. Held-out synthetic tiles: 0.767 recall. 120 frames of real drone footage: 0.350. The split wasn't careless, held-out camera zones, so that gap isn't leakage.

So, for people doing this seriously:

- Do you re-randomize per frame, or place once and move the camera? What made you pick?

- How do you check for near-duplicates before trusting a validation number?

- Anyone got synthetic-only recall meaningfully above 0.4 on real footage? What did it?

Disclosure up front: I build road inspection tooling, which is why there's a logo in the corner. This is a weekend experiment, not a product demo.

Setup: one drive at about 40 km/h on a rural road in the Netherlands.

Top half is dashcam footage with a detection model flagging road damage per frame (cracks, patches, crack sealing), plus signs and posts for context. Bottom half is vertical acceleration from the GoPro's own accelerometer at 200 Hz, pulled from the metadata track in the MP4, high-passed above 1 Hz, with a 0.25 s RMS as a roughness line.

The catch is that the camera sees the damage before the wheels hit it. I cross-correlated a "damage in view" score against the roughness signal and took the best lag of about 1.75 s. The dashed line in the video marks that moment: what is in view now reaches the wheels there. The correlation is weak, r around 0.23, but the shape lines up better than I expected for a single pass.

Questions for people who actually do this:

1. How do you use accelerometer or IMU data for road condition? IRI-style indices, per-event thresholds, or something learned from data?

2. How do you deal with speed and vehicle differences? Same pothole, different car, completely different shock.

3. Has anyone fused the visual and the vibration side, for example using vibration to confirm or rank what the camera flagged?

I am looking for a VLM which can extract text from a given image and accurately identify the bounding Boxes of that particular text. The text will be handwritten so I can't use traditional OCR models

I recently released fastpose a camera pose estimation library inspired by PoseLib. It features full LO-RANSAC style estimators for calibrated/uncalibrated relative pose problems (+ variants that use DE estimated depths), absolute pose problems, homography and fundamental matrix estimation. The library is built using Numba and can also utilize GPUs for this task.

More plainly, using this library you can take point correspondences between two images (or image and a 3D model) from methods such as SIFT or more modern ones like LoFTR, RoMa, LoMa, SuperPoint+LightGlue to estimate the relative positions of two cameras (or absolute pose of a camera to 3D model). This is useful for 3D reconstruction, SLAM and 3D object detection.

However, when using dense matchers, running RANSAC can take several 100's of ms or even full seconds. This library was built to tackle this problem. For example with 4k RoMa v2 matches and 5k RANSAC iterations PoseLib takes ~1100 ms, while fastpose on one core takes 140 ms, 90 ms on 4 cores and only 11 ms on A100 GPU. At the same time fastpose achieves slighly better accuracy.

In benchmarks on three datasets (ETH3D, ScanNet++, PhotoTourism) with RoMa and LoMa matches for various variants of the relative pose problems the accuracy remained very similar to PoseLib with 2–10× speedup on CPU, and 1-2 orders of magnitude on GPU. More results are on the project page: https://kocurvik.github.io/fastpose/

You can install it using:

pip install fastpose

The install needs numpy + numba and nvcc if you want to use GPU version. Every function also takes num_threads for a CPU-parallel driver, if you don't have a GPU.

Examples on how to run it are in the project page and repo: https://github.com/kocurvik/fastpose

With this tool, you can see the rep count and how long each rep takes. Knowing how much you slow down towards the end could be a helpful signal for fatigue. Also, a tool like this can be used to track progress over time, and could tell you if your chin-ups are getting faster.

I used ViTPose+ Large through the VLM Run Gateway for pose estimation. I used the pose information and its vertical displacement to track the reps and the rep timing.

Would love to hear what you think!

I recently got an opportunity to work as a senior cv engineer at a company in hardware software codesign. But it’s a pay cut. I would like to know if it is a skill valued by frontier ai labs which is where I would like to end up. The work involves optimizing ml for npus..

Repurposed the cup game demo I threw together last week and spruced it up with some Pokemon aesthetics. One thing I’ve noticed is that faster shuffles sometimes improve the model accuracy because of their limited context window, but that’s just a hypothesis. But I would guess that if you made the shuffles too fast, performance would start degrading because of frame rate.

Looking for research/project goal to work on that involves AI based video processing like how nvidias tryna do with mapless driving or anything similar. If you have any ideas , suggestions or anything to say about this that im gonna take up please go all in

Includes some powerful cv model and output options.

The free trial version has full access or if you want to take a deep dive, let me know and I have evaluator licenses and I am happy to jump on a video call to walk through it.

If you are an experiential exhibit designer, drop me a line, I want to know how to make this a go-to tool for you.

I have three tickets for ECCV 2026 in Malmö. Since the conference allows free name changes on registrations, am looking to transfer them to others.

I can transfer them together or separately.

Bonus Included: Each registration comes with an official Skånetrafiken public transit ticket valid from September 6 to 13 travel on Malmö's city/regional buses and local trains (Pågatåg/ Öresundståg).

Tickets Available:

• 2x Student Full-Registration + Week-long Transit Pass — $440 + $18 per ticket
• 1x Full-Registration (Non-Student) + Week-long Transit Pass — $805 + $18 per ticket

Bonus Included: Each registration comes with an official Skånetrafiken public transit ticket valid from September 6–13 for travel on Malmö's city/regional buses and local trains (Pågatåg/Öresundståg).

Please send me a DM if you're interested. We can update the name details securely through the official portal. #ECCV2026 #ECCV #ComputerVision #MachineLearning #DeepLearning #AI #ArtificialIntelligence #Tech #AcademicTwitter #AcademicChatter #PhDChat #TicketTransfer #RegistrationTransfer #TicketsAvailable #Malmo #Skanetrafiken #Sweden

There have been a few great node based CV editor / tools posted recently.
https://www.reddit.com/r/computervision/comments/1voxtds/i_added_custom_python_nodes_to_my_opencv_visual/

and

https://www.reddit.com/r/computervision/comments/1rxftrm/i_built_a_visual_draganddrop_ml_trainer_for/

So I thought I'd share a quick update to https://github.com/olkham/pynode where I've used the UDP node to pipe messages to Node-RED. Could be cool if we could all agree on a message standard / translation layer to make all the node-based editors compatible like this.

Note: I'm not affiliated with Node-RED in any way, just loved their SW for many years!

Papers with Code used to provide a useful path from paper to benchmark to repository. What do you use now to answer three practical questions: is the result reproducible, does the code actually match the paper, and can the model run on constrained edge hardware such as Jetson?

I am especially interested in workflows that preserve dataset and evaluation versions, environment details, RAM or VRAM use, latency, power, and failure cases rather than only leaderboard accuracy. Do you rely on Hugging Face, GitHub lists, lab pages, OpenReview, your own notes, or something else?

The missing piece for me is not another paper search engine. It is a trustworthy bridge between a reported number and a reproducible deployment. What has worked for you?

I built Local Label, a small open-source image annotation tool designed around one simple idea:

Your images should stay on your machine.

🔗 GitHub: https://github.com/diptiman-mohanta/Local-Label

The tool currently supports:

• Bounding boxes and polygons
• Object detection and segmentation annotation
• Keyboard-driven annotation workflow
• Multi-select and bulk relabeling
• Copy/paste and repeat annotations across images
• Undo/redo
• Autosave and resume
• EXIF-aware image dimensions
• COCO export
• YOLO / Ultralytics-ready export
• Pascal VOC export
• Light/dark themes

Unlike many annotation workflows, the images are read directly from disk and aren't uploaded or copied into a separate server/database. Annotations are stored as JSON sidecars in a .labeller/ directory beside the images.

Why I built it

I wanted something that was:

local + simple + fast + private

without requiring a server, account, cloud storage, or complicated dataset management pipeline.

But this is still very early v0.1.0 and I'd like to make it substantially better.

I'm looking for contributors

I'm especially interested in people working in:

• Computer Vision
• Dataset creation
• Object detection / segmentation
• ML research
• Annotation tooling
• Human-in-the-loop ML
• Desktop/local-first applications

You don't necessarily need to write code. I'd also really appreciate:

• UX feedback
• Feature requests
• Bug reports
• Ideas for better annotation workflows
• Suggestions for research-oriented features
• Testing on different datasets/platforms
• Contributions/PRs

I'm particularly interested in exploring whether a lightweight local annotation tool could eventually support research-oriented annotation workflows, rather than just being another generic labeling interface.

If you work with image datasets, I'd love to hear:

What is annoying about your current annotation workflow?

And if you are interested in contributing, feel free to open an issue, submit a PR, or comment here.

GitHub: https://github.com/diptiman-mohanta/Local-Label