Hello everyone!

I'm an engineering student, during my last internship at a medical device company, i was FORCED to count threads by hand, hated it so much that I wrote code that automated it, tried to turn it into a startup, not going all that great, so I thought I'll just document and release it, works on an Orange Pi and camera module, tested on a real production line, let me know if you have any remarks or questions, check it out!

https://github.com/Asxcvg/thread-counter

These conferences are now only for the top funded universities and industry labs really hard for a developing 3rd world country to get into.

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.

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.

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?

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.

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

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

World Labs just revealed their new omni world model, Atlas, and the space-time simulation features look like a massive leap for novel view synthesis and robotics training.

A few standout technical claims from their space-time simulation drop:

• Sparse-View "Bullet Time": They are generating frozen-time, free-camera multiview fly-throughs using footage from as few as three to five ordinary cell phones. No calibrated camera arrays, green screens, or professional capture studios are required to reframe the shots.
• Generative Real-to-Sim: For robotics, it doesn't just reconstruct a static 3D environment. As a simulated robot moves through the space, Atlas actively generates the RGB and depth data the robot's body-mounted cameras would observe along that specific trajectory.
• Physical Interactions: From casual real-world recordings, the model aids in building simulations that capture how objects move and interact. It supports rigid, articulated, and deformable objects, allowing users to dynamically alter lighting, backgrounds, and object positions to generate diverse robotic training data.
• Under the Hood: It’s built as a multimodal autoregressive diffusion transformer. Unlike models that rely on coarse text prompting for camera movement, Atlas uses precise camera geometry as a native input to ground everything in a shared "spatial context."

Faking Vision(FV) is an experiment in making visual information available to blind, non-living things.

It started very practically: I was trying to turn an image into flat files containing its visual information. That led to a bigger question: could a flat-file representation be model-agnostic — so that different systems given the same representation would produce the same object inventory and spatial relationships?

The attached examples a image (last image) turned into flat files by AI and then generated into image by another AI (so a generator which runs FV analysis on an image and turns it into flat files and another AI renderer which can ingest the flat files with FV algo and return an image).

(More examples available on twitter thread. https://x.com/MemoryPrismV1/status/2093276351549833484 )

Then came the next questions:

Can the same approach describe video rather than a single image?

Can visual information from different sources be sewn, stitched or patchworked together — for example image data, spatial information, lidar-derived information, etc.?

And once visual structure is represented this way, what happens if we deliberately manipulate it?

That last question is where Faking Vision became particularly interesting.

The underlying principles came from another project of mine, Making Vision, where I worked out a basic framework for how a visual system can acquire visual structure, extract useful information, generate candidates, selectively promote things for deeper processing, compare current information with existing knowledge, and update what it learns.

https://www.memoryprism.com/readings/making-vision

Faking Vision is the practical counterpart: if those are some of the things a visual system needs to do, can I construct and manipulate the information supplied to a blind system so that it can perform those operations?

I have been developing the flat-file representation, algorithm and testing process myself.

Now I need something I don't have:

models.

I want to test this with actual video-capable vision models, preferably several different ones, rather than build the experiment around a single system.

I'm not looking for someone to develop the project or explain computer vision to me. 😄

I have the experiment.
I have the process.
I have test material.
I need models to poke.

If you have access to a video-capable model/API/research system and would be willing to let me run some controlled test material through it, please come talk to me.

I have more examples here:

https://x.com/MemoryPrismV1/status/2093276351549833484

This complete @theworldlabs atlas thing, I guess i read a paper earlier this year from @TencentGlobal it named VerseCrafter (best of my knowledge). That did mostly same geometric control but this atlas one is little more better pipeline. Stitching a lot of things in a single place. But they are framing like huge like hugeee. Or I'm missing something.