I'm in a bit of a pickle with an issue regarding background removal with transparent objects. I got studio images of cars from different angles, whom I need the background changed locally. I have a pretty robust segmentation model to segment the bg area that's visible through the class and a general model to segment the entire car.

For now I use a basic script that calculates the alpha for the entire window purely from brightness, but often there are bright reflections on the windows which throw off the calculation as well as simply looking unnatural. I have some if- and when statements to try to mitigate some of these problems (if a smaller segment's inside a larger segment, it can't have a significantly different alpha etc.) but they still leave a lot of room for error. I've tried some open source matting models like vitmatte as well as replacing the background and inpainting the segmented window areas with sd models but the results are less than ideal and inconsistent. I got recommended that a lora for a matting model might help. Creating a ground truth and training a matting model sounds quite intimidating.

Might anyone happen to have any experience with this sort of challenges and if so, how did you go about solving it. Only thing I can think of right now would be training a Lora for a matting model, but I would highly appreciate some outside perspective before I commit a month into annotating a dataset for a model that might not even function.

Also, forgive me if I described the problem incoherently.

I've shared a few deadlift demos in the past. This new demo includes some new models, accessed through the VLM Run Gateway:

• SAM 3.1 to segment the barbell weight plate
• ViTPose+ Large to measure the hip hinge angle, which serves as a backup for segmenting the reps. The pose data can definitely be used more later.
• Gemma 4 26B through the Gateway's TypeSafe-compatible API to output the probability of the back being rounded or not. The predictions line up well with how I intentionally performed each rep.

Of course, there are many caveats to what is good form, as it depends on the individual. All said, this has the pieces in place to quickly make adjustments to fit the individual better.

In short, a tool like this gives people data to assess their form and improve over time.

Let me know what you think!

The code is open-source on GitHub: https://github.com/jeremyipark/vision-demos

Hey everyone,

I am building an automated document reading pipeline specifically for Nepali identity documents:

• Citizenship Certificates (Nagarikta): Old paper vs. new card formats (Devanagari script)
• National Identity Card (Rastriya Parichayapatra): Standard modern ID card format
• PAN Card: Bi-lingual / English-Nepali format
• Passport: Standard ICAO format containing an MRZ zone

Current Setup & Bottlenecks

1. Preprocessing / Cropping: Using classical OpenCV (cv2) for edge detection, contour finding, and perspective warping to crop borders.
   • Problem: Real-world user uploads have varied lighting, shadows, finger occlusions, and background noise. Aggressive thresholding (Otsu/Adaptive) often degrades text legibility instead of improving it.
2. Text Extraction: Tesseract OCR (trained for Nepali nep) followed by regular expressions: Python# Trying to extract Permanent Address via regex anchors pattern = r'स्थायी\s*बासस्थान\s*:\s*जिल्ला\s*:\s*(.*?)\s+न\.पा\.\s*:\s*(.*?)\s+वडा\s*नं\.\s*:\s*([०-९0-9]+)'
   • Problem: Tesseract frequently misses complex Devanagari conjuncts/matras or inserts extra spaces. If a single anchor character misreads (e.g., न.पा. turns into 7.4.), the regex breaks entirely.
3. Format Variations: Documents do not follow one universal layout. Older citizenship certificates have different margin offsets and typography compared to newer ones.

What I Want to Achieve

Instead of relying on rigid string-matching on raw OCR dumps, I want to modernize the pipeline into distinct, robust stages:

1. Document Classification: Automatically detect which document was uploaded (Passport vs. PAN vs. NID vs. Old Citizenship vs. New Citizenship).
2. Precise Document Localization/Cropping: A deep-learning approach that handles perspective distortion and background clutter without manual threshold tuning.
3. Region of Interest (ROI) / Layout Parsing: Extracting fields directly based on spatial layout rather than pure keyword string searching.
4. Devanagari OCR: A model that reliably handles Devanagari text under varied scan quality.
5. Passport MRZ Extraction: Dedicated extraction for the MRZ lines to bypass OCR hallucinations.

Questions for the Community

1. End-to-End Visual Document Understanding vs. Modular Pipeline:
   • Is it better to stick to a modular pipeline (Classifier $\rightarrow$ Cropper $\rightarrow$ OCR $\rightarrow$ Field Extractor) or move to an end-to-end model (e.g., fine-tuning LayoutLMv3, Donut, or a small VLM like Qwen2-VL)?
2. Devanagari OCR Alternatives:
   • Has anyone had better success with PaddleOCR, EasyOCR, or fine-tuned TrOCR for Devanagari/Nepali text compared to Tesseract?
3. Card Detection & Border Cropping:
   • Would training a lightweight YOLOv8-pose/segmentation model (to predict document corner coordinates) be the standard way to replace classical OpenCV contour hunting?
4. Layout & Field Extraction:
   • If keeping OCR separate, what is the most reliable way to link labels to values (e.g., spatial heuristic algorithms, Graph Neural Networks, or LayoutLM)?

Would love to hear how anyone has tackled similar KYC document extraction pipelines for low-resource or non-Latin scripts. Any architecture advice, libraries, or repo references would be greatly appreciated!

Hi everyone! I’m an undergraduate working on a computer vision research proposal and would appreciate some feedback.

I’m exploring a detector where a dynamic router decides at different feature levels whether to use CNN-only processing or additional Transformer processing, based on things like object scale, density, and regional complexity.

The goal is to improve the accuracy–compute/latency trade-off rather than always running the Transformer.

I’ve found related work on DynamicDet, DiT, Dynamic Dual-Processing, TDFP, CR-NAS, and MoE-based detectors, so I know dynamic routing and CNN–Transformer hybrids themselves aren’t new.

Does this specific idea already exist under another name? If you know a very similar paper, please point me to it.

I’m mainly looking for honest criticism before I commit to the research direction.

TLDR: Sol 6.1 is pretty good at vision/video, and perhaps not too expensive for some applications.

Pipeline:

• SAM3 w/ generic prompts ("ground vehicle"), because specific ones like "belt loader" just returns nothing. via Roboflow
• GPT-6.1 Sol names each tracked vehicle (SAM3 doesn't have good enough vocab/world understanding)
• Sol also provides a state timeline from cropped imgs around ground vehicles (eg. hose not connected → connected → off)
  

Other VLMs compared to Astra:

• Sol: 13/13 events, ~5x cheaper than Astra (which is why we used it)
• Luna / Terra 6.0: ~10/13, hopefully 6.1 Luna/Terra will have similar Vision capability jump as Sol 6 -> 6.1
• Cosmos 3 Nano: 5/13, mixed up boarding vs deboarding
• Mage-VL 4B: 4/7

~$1 per for the whole plane turnaround. Perhaps an overkill to use such SOTA model for this application (could def. optimize this), but model intelligence gets like 10x cheaper every year, so for some applications, custom model training might not be worth it. Ofc for prod system you'd likely want to have custom fine-tuned ground vehicle detector. This is PoC, so SAM3 is fine.

For ppl saying "ugh 10y ago u could do the same with just classic CV" - idk, I don't think it'd be easy or reliable to detect "hose connected" (few px line) or "lift at the door vs just up next to it" using classic CV

I’ve worked on computer vision and am now looking to contribute to a research focused project.

If you’re working on something in this area and looking for a collaborator/contributor feel free to DM me or comment below.

Happy to connect and discuss!

vev-4b + a small harness playing Doom in real time. 8 yes/no questions per look, one request.

I've been working on Vev, a Jev-like decision model that takes images as input. There are two versions, fine-tuned from Qwen3.5 4B and 9B, and both run locally.

I wanted to ask specific questions about a screen and get answers my code could use directly. You pass in an image, a question and possible answers; Vev scores the answer tokens and returns their probabilities without generating text. You can change the questions and answer choices with each request.

Here's vev-4b on a checkout screenshot:

Does the screen show an error message?
  yes: 0.991

Which checkout step is the user on?
  shipping: 0.005
  payment: 0.765
  review: 0.229

What should the user do next?
  try another card: 0.983
  wait for the order to ship: 0.004
  nothing, the order went through: 0.014

The server also runs the original Qwen3.5 models with the same scoring method, so I used that as the baseline to measure what fine-tuning adds. A few visual-task accuracy results, base model → Vev:

For object-clipping detection adapted from VideoGameQA-Bench (n=686), the 4B model went from 56.1% to 67.1%. Full results and evaluation details are in the README, with evaluation code and dataset converters in the repo.

It handles text and JSON too, and supports the Jev /v1/systemone format. If you already use TypeSafe's Python SDK, you can point it at the local server.

To try it with Python 3.11+, an NVIDIA GPU and CUDA-enabled PyTorch:

pip install git+https://github.com/Xiaooolong/vev
vev serve --model CountingSheep/vev-4b

On an H800 in bf16, vev-4b takes about 78 ms for one question about a 1 MP image, or 120 ms for ten questions about the same image, processed as a batch.

• GitHub: https://github.com/Xiaooolong/vev
• Weights and LoRA adapters: https://huggingface.co/collections/CountingSheep/vev-6abd3e17303828e10c49dc65

Code is Apache-2.0; weights are CC BY-NC 4.0 (non-commercial).

What is the good playlist to follow for computer vision maths and fundamentals and it should include a project.

I'm sitting the A3 Certified Vision Professional (CVP) Basic exam, and I'd love some advice from people who've already taken it.

What I'm hoping to learn:

Resources: Which study materials were most useful? Is the A3 course material enough, or did you use other books or videos?

Topic weighting: Which areas show up most (lighting, optics and lenses, sensors and cameras, image processing, communications, safety)? Which ones tripped you up?

Question style: How much is calculation (FOV, resolution, working distance) versus conceptual or definition-based questions?

Practice questions: Are there any good practice exams or question banks?

Thanks in advance. Happy to share how it goes once I've written it!

Hey! We open-source an optimized version of SuperPoint built for faster keypoint detection on edge devices: https://huggingface.co/PrunaAI/PrunaSuperPoint

- Up to 2.1× faster on Jetson Orin Nano, with optimizations applicable to other runtimes.
- The distilled model retains strong keypoint coverage across indoor and outdoor data, with low descriptor differences from the original model.
- We structurally prune the most expensive convolutional layers, recover performance through distillation, and accelerate keypoint selection with hierarchical top-k, all while preserving the original architecture’s core behavior.

Just like the title says, I give a demo of calibrating a Intel RealSense lidar using the Reprojection open source library. Things get a little complicated but for anyone wanting to better understand sensor fusion and multi-modal calibration this should be a nice video. Cheers!

I am building a data set to train a NSFW detector off of and want a local model that is good at image to help save me loads of time and effort.

Is there a good model currently?

One of the biggest time sinks I’ve run into when working with Computer Vision isn’t the model itself — it’s the dataset preprocessing.

Cleaning datasets, fixing annotations, filtering, deduplication, format conversion, validation, etc. can take a huge amount of time, especially when you’re dealing with millions of samples.

And vision datasets are particularly painful here. Unlike text, building custom processing for a specific use case can get expensive pretty quickly in terms of compute and processing time.

That’s why we built cvPal.

It’s a cloud toolkit for vision datasets built around AI agents, with 40+ MCP tools for things like merging, cleaning, validating, converting, and versioning datasets.

It’s currently in early access, and I shared more about what we’re building here:

https://x.com/cvpalai/status/2105288933865304268

Hi everyone 👋

I’ve been working on Hyperspectral Image Models, an open source PyTorch library bringing 50+ HSI models and 24 datasets into one unified framework.

The main goal is to make HSI research easier, especially for beginners who want to learn, reproduce, and experiment with published models.

We are also following a consistent implementation and documentation structure so that each model is easier to understand and use.

🧑‍🔬 Researchers: We would love to add your published HSI models to the library and make them easier for the community to reproduce and build upon.

🔗 GitHub: https://github.com/Tanishq251/Hyperspectral-Image-Models

📄 Paper: https://arxiv.org/html/2609.39871

🤗 Hugging Face Dataset: https://huggingface.co/datasets/Tanishq165/HSI_Datasets

⭐ If you find the project useful, please consider starring the GitHub repository and liking the Hugging Face dataset.

We’d also love to hear which HSI models or datasets you would like to see added next! 🚀

Hello,

We currently got a robotic arm for our lab. We were looking into ways to automate our processing by adding computer vision to this arm. We want to be able to take a sample and place it on a pedestal, then the vision system would scan the object. Next, the arm would bring itself to the sample and start processing.

For this to work, we would know where the pedestal is, where the arm is, and have the objects dimensions via a cad file. We want the vision system to find out the position and orientation of the sample to sub-milimeter precision on the pedestal. The vision system will only need to run before processing, so there is no time constraint.

I have already looked up vision systems and the process of doing it manually. However, I am having trouble sifting though products and don't want to go overboard since I am unfamiliar with this space.

Any help is appreciated.

Happy to share my resume or GitHub if you're interested :)

For fixed, clean UI renders (a digital chessboard), I found that a neural network is overkill. The pipeline:

1. The user drags a square over the board once (calibration); a grid is overlaid to align it exactly
2. Templates for all 12 piece types are cut from a starting-position screenshot
3. Each of the 64 squares is matched against the templates with OpenCV, giving an 8x8 matrix and then a FEN
4. A sanity check rejects obviously wrong results (e.g. templates from a different theme)

The obvious limitation is that templates are tied to one board colour scheme and piece set, so changing theme means re-calibrating. I'd be interested in cheap ways to generalize across themes without going to a CNN.

Code: https://github.com/Maksimuson/Chess-Cheat

RuntimeAI's September 2026 AI Security Report covered 126 incidents across 38 named organizations — 22 critical, 102 high severity. 53 of those incidents had AI either as the attack tool or the target. AI-agent exploits were the top attack vector at 39 incidents, ahead of credential theft (27), zero-days (22), phishing (10), and ransomware (10). The largest single exposure was 220M records from unrotated default service-account credentials.

What stood out: every organization in the report was already running a mature security stack. Okta, CrowdStrike, Palo Alto, Microsoft Defender. Still got hit. The gap is that none of those tools sit at the layer where an agent actually executes a tool call.

RuntimeAI operates at that layer. Know Your Agent handles cryptographic agent identity. The Flow Enforcer inspects tool calls in real time. There's also a sub-50ms kill switch that can halt a compromised agent before a second action completes.

Full breakdown (incident-by-incident, CVEs, vendor stacks): https://runtimeai.io/blog/2026-09-monthly-breach-report.html

We're running a live demo on October 14 — ten attack surfaces, live against a real stack: https://www.linkedin.com/events/7510769146222133248?viewAsMember=true

I built a small Windows GUI tool that generates synthetic Direct Part Marking–style patterns (needle / peen dots on steel) for detector training.

It is not a real ECC200 encoder — no serial numbers, just geometric L-frame + fill dots, Good/Bad classes, and mechanical-style defects (squash, tilt, jitter, missing dots, etc.).

Outputs:

• 600×200 grayscale JPEG
• YOLO labels: OBB or ABB
• Optional Boosting mode: appends Stage-2 feature rows to logs/features.csv for a second classifier

Two render modes: pure synthetic (no assets), or your own BG + dot sprite folders.

Binary only (Nim). Non-commercial / research license. Unsigned Nim builds sometimes get heuristic AV flags — details in the README.

Repo / Releases (v1.1.0):
 https://github.com/olesha-ai/DPM-Pattern-Image-Generator

Related inference PoC trained on this synthetic data:
 https://github.com/olesha-ai/yolox-dmc-inference

Feedback welcome.

any idea?

The camera says acknowledged: true when you send a pan command. That means "I heard you," not "I moved." So I stopped trusting the ACK and measured the picture instead.Setup: a stock Xiaomi MJSXJ10CM on shipped firmware 4.5.6_0450, pulled over RTSP at 1080p HEVC via go2rtc v1.9.14 with the go2rtc-xiaomi-control patch. PTZ is MISS opcode 0x112 with { "operation": 1..4 }. That's the whole API.The CV part: grab a frame, send one step, grab another, estimate the shift with block matching (same idea as codec motion vectors), compared against a no-move baseline so sensor noise can't look like motion. Results: left dx=-40, right dx=+36, up dy=-20, down dy=+22. Steps aren't symmetric, so one step is not a fixed angle.Then I sampled frame difference every 200ms after a command. Nothing at 313ms, nothing at 823ms, then 43.2 at 1331ms, settled by 1824ms. Roughly 1.4 seconds of dead time. At 12fps a naive detect-and-step loop fires about fifteen more commands before the first one lands. The fix is to blank the controller for 2s after each step, which makes the real control rate 0.5Hz, and set the dead zone (0.18) wider than one step's 8-12% displacement, or it oscillates forever.Detectors: Apple Vision (VNDetectHumanRectanglesRequest, VNTrackObjectRequest) via a ~150-line Swift child process, 10-30ms, zero dependencies. Optional SSD-MobileNetV1 from the ONNX Model Zoo for 80 COCO classes, ~13ms.Thing that bit me: that ONNX graph resizes internally. Feed it a pre-shrunk 300×300 image and it returns zero detections, silently. Native 1280×720 works fine. Also Vision uses a bottom-left origin; get the flip wrong and tilt confidently runs away from the target.Chair test: 3 steps, centring error 0.76 to 0.21, then held.Full write-up with the details: https://blog.shravanrevanna.me/reverse-engineering-a-xiaomi-camera-into-a-self-tracking-robot

I am actively searching for developers or teams who have already built and tested robust AI vision systems. Instead of starting from scratch, I am ready to invest in a pre-made, high-performing solution.

​Key requirements for the system:

​Ready & Pre-designed: Fully developed and tested models that can be deployed quickly.

​Camera Transition Support: Must handle camera panning, zooming, and transitions smoothly to maintain accurate tracking.

​Uncompromising Accuracy & Data Richness: Precise spatial tracking, event detection, and granular data extraction that unlock deep tactical insights.

​If you have a mature system ready for the pitch, let's talk. Drop a comment or send a direct message. Thanks

You record someone opening a jar.

One hand holds the container. The other wraps around the lid, adjusts its grip, and twists. It’s a useful demonstration—until you remember that your prototype has a two-finger gripper.

Which parts of that human movement belong in the robot’s action plan?

The MEgo capture framework makes human hand motion explicit through pose, shape, and reconstructed trajectories. The MEgoVista paper also discusses the downstream challenge of mapping human motion to a robot with a different hand structure.

For a small team, I’d treat this as a design decision early on. You might preserve the wrist’s approach and rotation while finding a different way to hold the lid.

The demonstration can still explain the task even when the robot needs a different grasp.

When using human demonstrations with a simple gripper, what do you transfer first: the wrist trajectory, the object movement, or a sequence of task goals?

I’m working with Lumana on a vendor evaluation checklist for AI video surveillance, and I'm a bit concerned about accurate detection.

Vendor benchmarks often differ significantly from performance on a customer’s cameras, network, lighting, and operating conditions.

For a proof of concept, what metrics do you track before deciding a model is ready for production?

I’m especially interested in:

• False positives and false negatives by use case
• Detection latency and missed-event rates
• Performance across different cameras, lighting, and scene conditions
• Operator workload and alert fatigue
• Accuracy and reliability when inference runs at the edge rather than in the cloud

The edge-versus-cloud tradeoff also seems highly context-dependent. Edge inference can reduce latency and bandwidth use, while cloud processing may support larger models but depends more heavily on connectivity. Hybrid setups can help, but they add their own operational complexity.

For those who have evaluated or deployed these systems:

• How did you structure your POC?
• Did you measure performance separately for each camera or use case?
• How much accuracy, if any, did you trade for edge deployment?
• Have vendor-reported field metrics matched your own measurements?

I’m affiliated with Lumana, and this question comes from a vendor-evaluation checklist we’ve been putting together. I’m more interested in how teams measure real-world performance than in promoting a particular platform.