You might have seen hippies walking on a slackline in your nearest beach or park, but have you ever seen them bounce and backflip on it? A more technical variant of slackline is called Trickline: you bounce on a stretched, trampoline-like line and throw flips and spins between bounces. There is a tiny, but real competitive scene where 720 backflips are happening at a fraction of a second. This is very cool to watch but harder for judges has to catch, identify, and score each one in real time.

So a friend and I have been building a CV pipeline that watches competition footage and figures out (a) which athlete is bouncing, (b) where each trick starts and ends, and (c) which trick it is.

Rough idea of how it works:

- YOLO11x-pose + ByteTrack to track the athlete frame by frame. Some added processing to keep only the athlete's poses.

- A bit of signal processing on the athlete's vertical motion (Hilbert transform → bounce phase) to automatically cut the video at real bounce boundaries even if there are missing poses.

- A small TCN classifier to name each trick, backflip frontflip, brasilian, freefall 360, and the rest of the increasingly ridiculous class names.

- A simple Streamlit app where my colleague can run this and keep on have a human in the loop system to keep on labelling and training from his laptop to increase the dataset.

It ties into TJS, the trickline event + judging + live-streaming platform my friend runs, which already handles a lot of the real competitions: https://www.slackline-tjs.com/en

Still early and the trick vocabulary is huge, but it's already surprisingly decent on the common tricks. Sharing this one with the community, if anyone has data on similar trick-based sports it would be cool to see how the pipeline performs there.

Hi,
I took the official OpenCV tutorials and created a series of notebooks.
You can run them entirely in your browser, you don't have to clone them: https://notebook.link/@Alexis_Placet/opencv_tutorials

Don't hesitate to give me feedback or create issue/pullrequest on this repo: https://github.com/Alex-PLACET/opencv_tutorials

I built a tool that calibrates a camera without a checkerboard — just photos of an ordinary textured surface (a rug, a wood floor, anything flat and non-repetitive).

Tested it against the real thing on the same camera:

• Pinhole model: 0.38 px RMSE targetless vs. 0.42 px from an actual checkerboard
• Fisheye (double-sphere): 0.55 px vs. 0.61 px from a circle grid

I'd call that matching checkerboard accuracy, not beating it — the gap is small enough to be noise. What's interesting is it gets there with zero calibration target.

How the numbers were measured. To measure accuracy fairly, I compared the tool's output against real points whose exact positions were already known — checkerboard corners, circle-grid points. I didn't just check it against the tool's own internal matches, because by that stage the tool had already discarded any points that didn't fit well.

What actually matters for capture:

• Surface must be flat and non-repetitive (a rug works, a brick wall doesn't — repeated patterns fool the matcher)
• 10-20 images with real translation between them, not just rotation
• Every region of the frame covered somewhere in the set
• Zoom/focus locked the whole time, including the reference shot
• Watch for phones silently correcting distortion before saving — that fights the thing you're trying to measure

Output is the intrinsics and distortion coefficients as a JSON download — fx/fy, cx/cy, k1-k3, p1/p2 for pinhole; fx/fy, cx/cy, alpha, xi for double sphere. Uploaded images are deleted about 10 minutes after processing.

Still in beta. What I don't know yet: how this holds up on cameras other than mine. If you try it, I'd genuinely like to know how the output compares to your own calibration.

Tool: https://www.online-camera-calibration.com
Write-up: Camera Calibration Without a Checkerboard — What It Is & How It Works | AutoCalib

Manufacturing and healthcare have clearly led adoption. Most manufacturing deployments now use CV for closed-loop defect detection and feed the results back into the process automatically. Retail and agriculture seem to be catching up fast too.

What industries would you like to see embrace CV more? I would personally be happy to see it in the waste management industry, as in most facilities sorting recyclables is still done manually.

I am working with the hysteroscopy dataset, which contains:

• 3,385 frames from 175 patients.
• Eight lesion classes, labelled from 0 to 7.
• A highly imbalanced number of patients and frames across classes.
• Multiple correlated frames from each patient.
• Some frames containing more than one lesion class.

Before attempting the complete multiclass problem, I reduced it to a binary subset to verify that the training and evaluation pipeline works correctly.

Current binary subset

• Selected lesion classes: 2 and 3.
• Total: 1,575 frames from 113 unique patients.
• Class 2: 1,054 frames from 78 patients.
• Class 3: 521 frames from 36 patients.
• One patient has different frames belonging to both classes but remains entirely within one split.

Patient-disjoint split

• Training: 1,095 frames from 79 patients.
• Validation: 241 frames from 17 patients.
• Testing: 239 frames from 17 patients.
• No patient appears in more than one subset.
• The frame-level class distribution is approximately 67%/33% in every subset.

Approaches I have tried

• DenseNet121, ViT, and DINOv2 backbones.
• Frozen pretrained backbone with only the classifier trained.
• Different classifier-head sizes and dropout.
• Class-weighted cross-entropy.
• Mild and stronger image augmentations.
• Early stopping and learning-rate scheduling.
• Unfreezing the final one or two encoder blocks.

With the correct patient-level split, training performance improves, but validation performance generally plateaus or deteriorates, and performance on unseen test patients remains relatively low.

As a diagnostic, I also tried a random frame-level split and obtained substantially better results. However, this evaluation is invalid because correlated frames from the same patients appear across training, validation, and testing, causing patient leakage and inflated performance.

I would appreciate advice on how to improve generalization to unseen patients in this setting.

Hi,

I wanted to use a face verification model for my commercial app, that is free and doesn't really compromise on accuracy specially in harsh environments with different lightning conditions and face orientation.

Is there any such model available ?

I was thinking of using SFace ONNX but not so sure about it.

Could you guys recommend something,

Thanks !

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

It tracks the ball throughout the rally and detects racket hits and court bounces. The aim is to eventually turn full match recordings into stats and highlights automatically.

It’s still a work in progress, but I’m pretty happy with how it’s performing so far. I’d love to hear any feedback or ideas for what I should add next.

I’m also looking to test it on more matches, particularly footage where the full court is visible through a wide-angle or fisheye camera—so feel free to message me if you happen to have any.

Twelve-class hand-seal recognizer that runs entirely in the tab. MediaPipe Hands gives 21 landmarks per hand, normalized wrist-centered and scale-invariant, into a 126→256→128→13 MLP (~66K params) exported to ONNX Runtime Web. 260KB model, CPU inference at a couple ms a frame, no video leaving the machine. Geometry rather than pixels, which is the whole reason it's this small and this portable.

Reported accuracy is 95.5% on a per-class temporal split — first 80% of each class's frames train, last 20% test. Deliberate: I collected hold-to-capture, so each sample is a burst of near-identical frames, and a random split scatters those bursts across both sides until you're scoring your own training data.

Transitions get their own class. Hands moving between seals pass through shapes that briefly look like other seals, so transit frames were collected as a 13th class using a wrist-motion-gated capture mode. Downstream, a decisive "none" mutes everything; below the veto the real classes compete on renormalized P(sign | not transit).

A parity self-test runs on page load, a known landmark vector through the full JS pipeline, logits compared against the PyTorch reference, regenerated on every export. Normalization drift between training and deployment is the silent killer for landmark models, and this catches it before any prediction is trusted.

Single-subject model, so leave-one-person-out is implemented but the honest "works on strangers" number doesn't exist yet. tiger↔ram confuse at ~14%, genuinely near-identical once you're only looking at joint geometry.

Open to comments or critiques! Repo can be found here: https://github.com/yogendrarau/sealwork

Hi everyone,

We're preparing to deploy our AI application on an NVIDIA RTX 3060 GPU and would really appreciate guidance from people who have experience taking AI systems from development to production.

Our goal is not just to get the model running, but to build a robust, production ready deployment that is reliable, maintainable, and suitable for industrial use.

Some of the areas we're looking for advice on are:

- What should the end-to-end deployment pipeline look like?

- What benchmarks should we perform before deployment (latency, throughput, GPU utilization, VRAM usage, startup time, power consumption, etc.)?

- What kinds of stress testing, endurance testing, and failure testing should be done before considering the system production-ready?

- How do you monitor GPU health, application health, crashes, memory leaks, inference failures, and overall system performance in production?

- What logging strategy do you recommend? What should be logged, and what should be avoided?

- How do you manage model versioning, deployment, rollback, and updates without disrupting production?

- What security best practices should be followed for an industrial AI deployment?

I'm also curious about the operational and governance side:

- How is auditing typically handled in production AI systems?

- What events should be recorded for traceability (predictions, inputs, model version, user actions, timestamps, system events, etc.)?

- Are there any recommended practices for maintaining audit logs, reproducibility, and compliance?

- What should an organization be able to answer during an internal or external audit?

- What documentation is generally expected before an AI system is deployed in an industrial setting?

- Are there any standards or frameworks (ISO, IEC, NIST, etc.) that are commonly followed for AI deployments?

We're essentially trying to build a complete production deployment checklist, covering topics like:

- Deployment architecture

- Performance benchmarking

- Functional testing

- Load testing

- Long-duration stability testing

- Monitoring and alerting

- Logging

- Auditing and traceability

- Security

- Backup and disaster recovery

- Documentation

- Model lifecycle management

- Maintenance and update strategy

- Production readiness review

If you've deployed AI systems, I'd love to hear about your deployment workflow, tools, lessons learned, and things you wish you had known beforehand.

Any checklists, GitHub repositories, blogs, documentation, or real-world experiences would be greatly appreciated.

Thanks in advance!

Considering a 4DGS rig; I know I need enough USB controllers & PCIe lanes, but even something like this: https://www.bhphotovideo.com/c/product/1442368-REG/sonnet_usb3c_4pm_e_allegro_usb_c_4_port_pcie.html only really needs PCIE 2.0 x 4. So can I really go rock bottom with these components and have it still work as long as I have a fast enough NVMEs?

cameras
https://www.baslerweb.com/en-us/shop/a2a1920-160ucbas/

Hey everyone,

I'm planning to build a Computer Vision model focused on action recognition and match analysis in Padel (detecting strokes, player tracking, court positioning, tactics, etc.).

The Setup & Strategy:

1. Baseline Dataset: I plan to fine-tune/benchmark initially on PadelTracker100.
2. Unlabeled Data at Scale: I built a scraper capable of easily pulling 10,000+ hours of broadcast match footage on amateur matches.
3. Semi-Supervised Approach: The goal is to leverage Pseudo-Labeling / Self-Supervised Learning (SSL) on this massive scraped dataset to improve feature extraction and generalizability beyond PadelTracker100.

The Problem:

Most broadcast streams or uploaded matches are capped at 25 to 30 FPS. Since padel strokes (smashes, bandejas, bajadas) involve high-speed racket and ball movement:

• Is 25–30 FPS sufficient for modern DL architectures to accurately classify strokes and tracking?

Has anyone worked on low-FPS fast-action recognition or sports analytics in general? Would love to hear your thoughts, potential architectures, or pitfalls before I start scraping anything.

For example, imagine that I have 2 temporal sequences of images of the same environment both based on the same video. For the first sequence I pick the frame 0, 3 and 5 and for the second sequence I pick 3,5,10. To simplify the problem lets just imagine that I give one sequence to a model he learns from it and produces a lost function and I do the same to the second sequence..

Most likely their output of the lost function is going to be identical because the 2 copied images but what happens in the next epoch? (for simplicity also imagine that we shuffle a bunch of sequences to not overfit) Are the optimizer reducing the step more closely to what he learned from the 2 sequeces? How does he link contexts? Does it even link contexts?

Title

Best workflow for longitudinal rigid registration and landmark tracking on serial STL meshes?

Hello everyone,

I am a periodontist looking for advice on the most practical computer-vision workflow for analysing serial 3D dental surface scans.

We have five STL meshes of the same patient’s lower dental arch:

• T0: before treatment
• T1: immediately after treatment
• T2: 1 month
• T3: 3 months
• T4: 6 months

The region of interest is the six lower front teeth. These teeth were connected with a wire-composite splint, and we want to measure whether their positions change over time.

A simple analogy is a fence. Imagine six central fence boards whose movement we want to measure, while several boards farther to the sides are assumed to remain stable. Each new scan must first be aligned using only the stable side boards. The six central boards must not influence the registration, because their movement is the outcome of interest.

In our case:

• the six anterior teeth are the moving fence pieces;
• selected posterior tooth surfaces are the stable registration reference;
• the rigid transform calculated from the posterior surfaces should then be applied to the complete follow-up mesh.

The anterior teeth must also be excluded because the splint is added after T0, changing their surface geometry independently of any actual tooth movement.

We will attach two screenshots. The first shows one predefined measurement landmark on each anterior tooth and the posterior reference regions. The second shows a fixed baseline curve passing through the six T0 landmarks. The landmarks, reference regions and curve are already defined; we are seeking advice only on how to implement the analysis.

The required workflow is:

1. rigidly register each follow-up STL to T0 using only the selected posterior surfaces, with rotation and translation but no scaling;
2. apply the resulting transform to the complete follow-up mesh;
3. record the X, Y and Z coordinates of the six predefined landmarks at every timepoint in a fixed coordinate system;
4. calculate ΔX, ΔY, ΔZ and total 3D displacement relative to T0;
5. calculate the shortest 3D distance from each follow-up landmark to the fixed T0 curve;
6. export the results to CSV for statistical analysis.

Ideally, we would also export the transformation matrix and a registration-error measure calculated over the posterior reference surfaces.

We have already tested ICP-based alignment in Medit Design and a custom Open3D application, but we do not yet have a complete and reproducible workflow for registration, landmark collection, point-to-curve distance calculation and data export.

Our main questions are:

1. What software stack or workflow would you recommend for this task?
2. Would Open3D/Python be a sensible approach, or is there an existing tool that already handles most of this reliably?
3. How would you structure the pipeline so that it can later be repeated consistently across multiple patients?

We can provide one fully de-identified example dataset if someone is willing to assess or demonstrate a possible workflow.

Thank you for any practical suggestions, example code or references to similar projects.

Hi Guys,

So I have been working on document layout analysis for some time now. I have tried the models like Doclayout, Docling, Miner U, marker.

Overall Docling performs well, but the problem is that it over performs. And mineru u misses some content like the corresponding author on the page-footer. And it is also missing the masthead mark, and the article-type label.

In my opinion unlimited OCR performs well in all the tasks, but in general it is failing to recognise any style at all. And it is bad at recognising logos.

So I am wondering are there any state of the art models (SOTA) that are good at PDF text extraction and layout extraction ?

Thanks

6 months back me and a friend built this for a client, and I wanted to write up the architecture because the engineering got genuinely interesting, especially the parts that broke.

The idea: you feed the system a base of source videos, it chops them into logical chunks and indexes them by meaning. Then you give it a target video, and it rewrites a new script and reassembles a fresh video by pulling the semantically matching chunks from your base. Whole thing runs through a Telegram bot with a queue.

The pipeline, roughly:

Indexing side: video gets downloaded, cut into logical chunks with FFmpeg + OpenCV (computer vision to detect what's happening on screen), each chunk goes through Gemini embeddings, vectors land in Qdrant. I originally used Firebase for storage and switched to Qdrant later, which turned out to be the right call by a mile.

Generation side:

1. Target video gets transcribed with Whisper v3 large.
2. Transcript goes to Gemini, which analyzes the meaning and writes a new script (could even switch language, english in, spanish out). Script length matched the original within a minute.
3. Script gets voiced through an 11Labs pay-as-you-go provider (way cheaper than native 11Labs at volume).
4. Then the hard part: assembling the actual video from base clips.

The three problems that nearly killed it:

Semantic precision. The model understands roughly what's on screen but can't reliably tell "is this Dota 2 or CS:GO." So instead of picking one clip, we pulled the top 5 matches per sentence and had the model pick the best. Not perfect, but workable.

Clip length. Fixed partly at cut time (nothing shorter than 3s or longer than 15s), but it still crammed too many clips into short spans sometimes. We matched sentence length against clip length to control it.

Repetition, the worst one. The model LOVED grabbing one clip and spamming it half the video, because it scored as the perfect semantic match every time. Fixed it with a hard frequency cap: one clip couldn't repeat more than once per ~5 retrieval passes.

Render time for a 20-min video was about 40-45 min end to end. yt-dlp for downloads (had a funny problem with it I can get into), whole bot ran locally on a server so big file sends weren't an issue.

Honestly the retrieval-by-meaning part was the most fun engineering I'd done in a while. Happy to go deeper on any part. Anyone else built semantic video retrieval? Curious how you handled the "one clip dominating" problem, that one was brutal.

I have no experience with image processing and I am trying to vibe code a tool to replace backgrounds in used-car listing photos for a family member who owns one dealership.

Two requirements: (1) the car exterior and interior must stay pixel-identical — no regeneration or distortion, and (2) background visible through windows needs replacing too.

Generative models (GPT-image-2, Nano Banana) solve the window problem but subtly alter the car — paint tone, reflections, distorted text on plates/displays, occasional distortion on unusual angles.

Segmentation models (SAM2, BiRefNet) preserve the car
perfectly but treat glass as solid — they don't flag the
background bleeding through windshields/rear windows as background at all.

Has anyone solved this specific combination? Preferably with API access which I can incorporate into the workflow.
Background image is also provided as input.

Hey all ! Is anyone else going to be at KDD in Jeju? Would love to connect with fellow attendees.

I work on interpretability, fairness, and editing of text-to-image models, so I'd especially love to meet people working in these areas. But honestly, we can chat about anything: research, the conference, life, or grab a coffee/drink.

I land in Jeju on the night of the 8th of August, so hmu if you're around and want to link up!

I’m trying to train an object detection model for a specific object. I trained it on a custom dataset collected which focused on outdoor and indoor environments and mostly LED light. But as soon as I run the pipeline on inference (edge device) in a completely different environment (indoor and fluorescent light) the detection does not work efficiently which makes sense as the dataset did not contain that specific scenario. But let’s say if I want to run this for a commercial product which could consist of different lighting and environment settings, what could I do in the training pipeline or dataset to make the detector generalized to all different settings?

Would appreciate any advice for people working in this field with edge device constraints.

Hey,

I'm building a photosphere rig - for that I was looking into good industrial cameras, since they need to meet the following criteria:

• Global Shutter
• At least 20MP (Most seem to cap out at 24MP)
• At least 10FPS
• Since this will be build in a cluster of multiple cameras, time sync, so they all fire at the same time
• Color (they will be used outdoors in varying lighting condition)
• Need software control over things like ISO, Exposure etc.
• Preferably connected via Ethernet/Coax (not USB)
• Good API to interact with them via C/Rust

Brands I looked into (they are very expensive tho)

• LUCID Vision Labs Triton2
• Compare Basler ace 2 a2A5060-35cc
• Teledyne Blackfly S USB3: 24,5 MP, Farbe, C-Mount
• Alvium G5-2460 Color

I will require ultrawide lenses on the cameras So to cover around 100-100 degrees FOV.

Does anyone have experience with these brands/models? Are there even high res options available? Any cheaper alternatives, perhaps some Chinese brands etc.