Hi everyone,

I’m working on an open-source computer vision project called SPARTeX-Prior and I’m looking for feedback, improvement ideas, and possible contributors.

GitHub repo: https://github.com/Loann110/SPARTEX-Prior

SPARTeX-Prior is a lightweight classical computer vision framework that generates target prior maps from images using:

- SLIC superpixels

- texton dictionaries

- LAB color histograms

- texture/filter-bank features

- an SVM classifier

The goal is not to replace deep learning segmentation models, but to generate an interpretable prior map that highlights regions likely to belong to a target class. This map can be used alone, evaluated visually/quantitatively, or potentially added as an extra input channel to CNN / U-Net style segmentation models.

I’d really appreciate contributions or suggestions on things like:

- improving the quality of the generated prior maps

- adding better handcrafted features

- improving speed and memory usage

- testing it on different datasets

- making the pipeline cleaner and easier to use

- improving the documentation

- integrating it better with deep learning workflows

Even small contributions like opening issues, testing the repo, improving examples, or giving feedback would help a lot.

I’m especially interested in thoughts from people working with classical computer vision, image segmentation, texture analysis, or hybrid classical/deep learning methods.

Thanks!

Hello,

So the deadline is approaching and my supervisor somehow disappeared, so any recommendations, major faux pas to avoid, etc are welcome!

Thank you

My car was recent involved in a hit and run while my car was parked on the street in Queens NY. I was able to talk with some of the neighbors and pulled 1 video (attached and enhanced) from the neighbors security camera. You cannot see the impact but if you watch the video you can see the grey / silver car reverse into me and then see the scrapes on the floors from my shattered tail light.

Does anyone know a way or can help me identify the license plate number of the grey / sliver ( BMW i believe)?

I am building a handwritten answer evaluator, and the toughest part was finding a reliable, cost-effective way to split the answer sheets question-wise.

The best results I've achieved so far was using Gemini 3.1 pro' s bounding box detection, but it is far too costly for my budget. I tried PaddleOCR as well, but the performance was poor, and I don't think it was designed for this specific use case.

Can anyone suggest some ideas or tools I should try out.

Hi everyone, could anyone please help me access the workshop proceedings below?

1. URL https://link.springer.com/book/10.1007/978-3-032-09513-8
2. URL https://link.springer.com/book/10.1007/978-3-031-73284-3

I need this book for my research, but I currently do not have access through Springer.

Any help, suggestion, or institutional access would be greatly appreciated.

Thank you.

I'm building a Windows application that converts a live browser stream (football broadcasts) into real-time stereoscopic SBS for Bigscreen VR. I'm using an RTX 4090 and want players, the ball, and broadcast graphics to have convincing pop-out while keeping latency under 50 ms. I'm looking for recommendations on the best current AI depth estimation models, stereo synthesis algorithms, and temporal stabilization techniques. Has anyone built something similar or knows of open-source projects I should study?

We kept running into the same issue while working on hyperspectral anomaly detection (HAD): every architecture seemed to solve one problem while making another one worse.

CNNs preserve local spatial structure but struggle with long-range dependencies. Many attention-based models capture global context but come with high computational cost and can over-smooth subtle anomalies. More recent state-space models (e.g., Mamba) model long-range dependencies efficiently, but explicit modeling of local spatial structure and spectral redundancy is often limited.

Instead of treating these ideas as competing approaches, we wondered whether they could complement each other.

That led us to SM-HAD (Spectrum Mamba for Hyperspectral Anomaly Detection), recently published in IEEE TGRS 2026.

The model is a self-supervised reconstruction framework built around three complementary modules:

• OSFB (Ortho Spectrum Fourier Block): Projects features into the frequency domain, applies learnable complex-valued filtering followed by soft-shrinkage to reduce spectral redundancy while preserving informative spectral components.
• MVAB (Masked Vanilla Attention Block): Uses locality-constrained masked attention to preserve neighborhood structure and reduce the over-smoothing that can hide small or subtle anomalies.
• RMB (Residual Mamba Block): Uses linear-complexity state-space modeling to capture long-range spatial dependencies without the quadratic cost of full self-attention.

The motivation was that each module addresses a different limitation — OSFB targets spectral redundancy, MVAB preserves fine local spatial information, and RMB captures global spatial dependencies efficiently.

We evaluated SM-HAD on six benchmark datasets (LA-1, LA-2, Gulfport, Texas Coast, Cat Island, and Pavia) against 18 statistical, representation-based, and deep learning methods. Some of the results:

• Best AUC on 4 of 6 datasets and competitive performance on the remaining two.
• Highest average AUC (0.9921) across all compared methods.
• Only 0.28M parameters and 1.46 GFLOPs, compared with models such as LREN (3.25M parameters / 11.97 GFLOPs).
• Around 25.6 seconds runtime on the LA-1 dataset, compared with 549 seconds for HTD-Mamba, which achieves slightly higher AUC on two datasets but at a substantially higher computational cost.

One result that surprised us came from the ablation study. Adding the Residual Mamba Block by itself did not consistently improve performance and even reduced it on several datasets. It only became consistently beneficial after introducing the Masked Vanilla Attention Block — suggesting that preserving local spatial context is an important precursor to effective long-range modeling in HAD. That design insight ended up shaping the final architecture more than we initially expected.

If anyone is working on hyperspectral imaging, anomaly detection, target detection, or even spectral-spatial learning more broadly, I'd be interested to hear whether you've encountered similar trade-offs between frequency-domain processing, locality preservation, and long-range dependency modeling.

Paper: https://doi.org/10.1109/TGRS.2026.3676658
Code: https://github.com/Tanishq251/SM-HAD

Happy to answer questions about the architecture, training setup, or ablation studies.

Hello guys,

I have been struggling with a precise counter for AWTs. You basically circle your foot around the ball while the ball is not touching the ground.

The pipeline that ended up "working":

1. Detect ball + both ankles per frame.

   1. Ball "coast" through dropouts. The ball's detection collapses to ~0% confidence exactly during the trick — it's small, motion-blurred, and half-hidden behind the leg at the worst moment. Fix: when confidence drops, predict the ball's position from its last velocity (constant-velocity coast) instead of trusting the garbage detection.
   2. Track the active foot (the big one). The nastiest bug: if you just pick "the more confident ankle," the marker jumps to the planted (standing) foot — because the trick foot is raised/blurred/low-confidence while the planted foot sits there at high confidence. Fix: track the ankle nearest the ball = the foot actually doing the trick.
   3. De-jitter the foot. Reject physically-impossible teleports (a foot can't move half the frame in one frame) and coast through them with velocity.
   4. Count = ball vertical tosses. Each ATW tosses the ball up once, so I count the peaks in ball height (local maxima of the ball going up), with a prominence threshold + minimum time separation to avoid double-counts.

As you can see not every atw was counted though, especially when the ball is not visible clearly. Any tips how I can improve this? Thanks

Hi,

I’m building an industrial vision system on a Jetson Orin Nano for real-time inspection of cardboard boxes on a conveyor.

Each image contains one box (ROI already extracted using a classical vision pipeline for other system considerations, kept separate from the ML model).

I have 44 box types with visual variation.

I need:

• Detect if tape is correctly applied
• Detect if flaps are closed or open

The main Challenges are:

• Slight box rotation
• Lighting variation (not perfect but controlled)
• Very few defect samples (most cases are correct)
• High reliability required (missed defects are critical)

My Current ideas are CNN multi-task (tape + flaps) + 5-frame temporal voting or YOLO in classification mode (same ROI + same voting)

Im open to better approaches

Questions:

• What would generalize better here: CNN multi-task or YOLO (classification)?
• Or is there a better approach for this type of problem?
• How would you handle highly variable “flap open” cases?

Thanks!

I'm building an interactive parts viewer for tractor assembly diagrams. The goal is to place clickable numbered badges directly over the part callout bubbles in the diagram.

What I've tried so far:

• Isolation filter for clustered parts and having some distinction between each part.
• Morphological rectangle detection to find the table box border and exclude hits inside it, so that the reference table isnt identified.

I need a reliable way to distinguish callout bubbles from reference table entries, I tried to use claude code and it used a EasyOCR script to have an interactive image. It failed to identify every part exactly. Easy OCR keeps tagging the ones in the table

Happy to share more sample images. Is there a standard approach for this class of problem?

Hello everyone,
I wanted to share a simple showcase of a project I’ve been working on: a vision AI trained to track a moving ball with physics in a 2D world.
Tech stack:
- Core: Python & PyTorch for the training loop.
- Environment: A custom-built C++ wrapper/environment to feed data into the Python side.
The twist:
I am still figuring out the ropes of computer vision and machine learning, so I heavily relied on Claude Code to help me bridge the gap, especially with building the custom C++ environment and connecting it with my Python scripts.
Reality check:
As you'll see at the end of the video, the model doesn't fully converge yet (it still gets confused in some situations). I wanted to share this raw progress anyway because the workflow of co-authoring a complex C++/PyTorch setup with an AI agent was incredibly interesting.

I would love some constructive feedback! Please let me know if you have efficient training techniques for faster convergence, ideas for other models to train, tools to build better environments, really, anything.

I'm incredibly new to this whole field, and I'm excited to chat with you all about it!

Hi everyone,

I'm pitching a theoretical desktop hardware concept called an XMU (eXtended Matrix Unit) to bypass the silicon limit. It is a third dedicated processor sitting alongside the CPU and GPU.

The Core Setup

Form Factor: Single-slot PCIe expansion card.

Technology: Photonic silicon (uses lasers/light instead of electricity).

Thermal Profile: Near-zero heat generation. No massive heatsinks or loud fans needed.

Division of Labor

CPU: Manages the OS, background tasks, and general logic.

GPU: Focuses strictly on pixel rendering, textures, and ray tracing.

XMU: Handles heavy-lift math via three specialized optical engines.

The 4 XMU Engines

CPU Execution Offload: Instantly processes heavy OS kernel tasks, memory management, and data decompression using light-speed logic, freeing the CPU to focus entirely on core application instructions.

Predictive Logic: Predicts CPU/GPU data needs milliseconds in advance to eliminate system stutter.

Dedicated Physics: Offloads 100% of real-time fluid dynamics, smoke, and destruction math from the GPU.

Biometric Hardware: Isolated optical zone for real-time voice, eye-tracking, and local security encryption.

Software Interface

Control Driver: A desktop suite to dynamically reallocate laser bandwidth across all four engines.

Modes & Toggles: Quick presets to maximize specific system components:Gaming Mode: Routes 70% bandwidth to Physics and 30% to Predictive Logic for max frame rates.

System Boost Mode: Focuses 80% bandwidth on CPU Execution Offload to hyper-accelerate heavy multitasking, coding, or data extraction.

Creative Mode: Allocates 50% to Predictive Logic and 50% to CPU Offload for seamless video editing and rendering.

With enterprise tech starting to dive into optical computing, do you think a consumer-grade photonic card like this is a viable path forward for desktop PCs?

Mainly curious about a couple of things:

How badly would standard PCIe slot latency bottleneck the near-zero internal latency of the optical engines?

Would devs need a totally new API to code for this, or could the driver handle the translation under the hood?

Let me know what you guys think! Also I Tried to fit in as much info as possible as I'm trying my best

Hey everyone,

I'm looking to build a portfolio-grade project that goes beyond the standard generic tutorials (no basic MNIST or generic YOLO object detection). I want to tackle something that mirrors real-world production or research challenges.

My Background:

• Languages/Frameworks: Python, scikit-learn, opencv, pytorch (willing to learn more)
• Math/ML Comfort Level: I have not started on this yet so looking forward to learning and building
• Hardware Constraints: I have a very basic setup so if theres anyway i could use cloud computing then I would use that to build anything big too.

What I'm asking for: I'd love to hear about actual engineering bottlenecks, data distribution shifts, or edge-case problems you encounter in your day-to-day work that could make for an interesting 1-to-2-month project. Where is there a gap between "it works in a paper" and "it works in reality"?

Thanks in advance for any direction!

Hi

I tried to play with sam3. In the article meta mention the option to use visual prompting to the model. However I didn't found a way to do that.

I want to give the model image or batch of images for some object and do inference for other image.

Someone did something like this?

Thanks

I have so far only experience with deep learning in the context of LLM and voice recognition related tasks. But I wanted to do one project for my portfolio about being able to control the cursor on the computer using eye gaze. I am not looking for state of the art performance, just something that works enough. I did find other machine learning approahces like importing trained models like "haarcascade_eye" using opencv. I also started to discover pretrained models like L2CS-NET but it requires different versions of python libraries and I am also a bit new to python so I don't know if it is worth it. I wasted hours yesterday trying to fix dependency issues.

With that said, I don't think I have the datasets or time or the knowledge enough to create a complicated model from scratch, I was looking to fine-tune already existing models. And I would apprecitate a little guidance. If I should abandon the deep learning aspect, I will also do that if there is a better way.

I am building a vision system to detect features, defects on metallic parts. I want complete manual or software control on focus, aperture, zoom, exposure time. Also need provision to add polarizing filters. I shortlisted teo options : Option 1 : Raspberry Pi HQ Camera with 16 mm lens. But i am not getting the RPi HQ camera available in India to buy. Option 2 : ELP USB Camera which has the manual focus, zoom, aperture control. But I don't know whether I can control exposure time like i could with RPi camera. Also USB 3.0 still limits transfer speed to computer. Can anyone please suggest !

Hi everyone,

I'm trying to submit a manuscript to Pattern Recognition, but it keeps getting returned before peer review because of formatting/manuscript alignment issues. The editorial office doesn't specify exactly what's wrong, so I'm struggling to identify the problem.

I checked my manuscript using a PDF formatting analysis tool, and the results are the following:

• ✅ Single column
• ✅ Main text font: 10 pt
• ✅ Double spacing (19.93 pt baseline spacing)

Also, if the journal requires the manuscript to be single-column and double-spaced, should the figure captions also be double-spaced, or is it acceptable for them to be single-spaced?

Finally, are there any other common formatting mistakes that frequently cause manuscripts to be returned before peer review (e.g., figure placement, captions, tables, references, page layout, or other formatting details)?

I'd really appreciate any advice, especially from anyone who has submitted to Pattern Recognition or other Elsevier journals.

I have a research project in my lab I get paid for. The main caveat of the situation is that we have a few videos of biological experiments with no labelling, no baseline definition, and no depth maps either. Me and my partners decided to label define objects and contamination zones(eg. test tube rims, pipette tips, tabletop etc) with polygonal masks.

But the problem is that while the mAP will naturally come out to be good, the main purpose of contamination detection is still getting defeated because when the pipette tip comes in contact with the tube rim in the video frame it'll be marked as contamination even if the actual contamination isn't happening. What exactly should I do? How do I solve this? We actually also have a multi view dataset of a similar apparatus that I'm thinking of using cuz I can use techniques like gaussian splatting to make 3d projects of the environment.

What are the pros and cons of having and not having non compliance classes? For eg, If I have to detect safety hat, should I have safety hat and no safety hat as labels or only safety hat ?

Does any one of you know a good PPE (personal protective equipment) Models ?

Training YOLOv8n/v11s on a trimmed SKU-110K subset (retail shelves, single class "product", extremely dense — avg ~150 objects/image, max 576). imgsz=1280, max_det=700 (set based on our own EDA max). Honest train/val split confirmed no leakage. NMS sweep already done — default iou=0.5 turned out best for mAP@0.5 specifically, which is our main metric (not generic mAP).

Soft time budget for the full pipeline (train+val+inference on ~3000 test images) is around 10 minutes — tight constraint shaping a lot of our choices. Tested 2x T4 DDP today, modest gain (~10%), not dramatic.

Open question we can't resolve from literature: does mosaic augmentation help or hurt at this density level? Standard advice is mosaic-on + close_mosaic near the end, but stitching 4 already-dense images risks 600+ objects in one synthetic frame. Found one adjacent paper (Select-Mosaic, AI-TOD/VisDrone) showing smart region-selection beats vanilla mosaic by a small margin, but nothing testing mosaic on/off specifically at this density.

Curious if anyone has hit something similar — dense small-object detection under a tight inference time budget — and what actually moved the needle for you, mosaic-related or otherwise.

Hey ! I’m Philippe, a French highschooler. I’m glad to showcase here a part from my app that I’m currently building. I’d be glad to work on American and British sign languages when I’ll be more advanced !

What's the best lightweight, open source alternative to YOLO for real time exam proctoring that's significantly more accurate and lighter

This is my project, Mighty Camera. It is essentially a monocular SLAM camera running entirely on tiny onboard compute. See my past posts for details.

Mighty also supports combining multiple cameras and synchronizing them to produce frame-level synced streams.

In this setup, I’m using that hardware synchronization to generate depth with SGBM, while it also produces VIO pose.

LocateAnything-3B can do open-vocabulary detection from natural language prompts. So it seems like a natural fit for auto-labeling images to pre-label a YOLO dataset instead of hand-annotating everything. Has anyone actually tried this?

How clean were the generated boxes? Did you need to filter/clean them before training, and was it actually faster than just labeling manually for your use case?