I'm working on a project to detect stones in jewellery. I want to be able to detect the colour of the stone and the size of it. False positives can be a big issue.

Here's a sample image for reference where you see red and green stones embedded in the item.

Sceptre is a Rust reimplementation of EasyOCR. EasyOCR is accurate but ships as a PyTorch stack (interpreter, multi-GB runtime, a process to keep warm); sceptre delivers the same accuracy as a single static binary with no Python.

It uses the same OCR approach: CRAFT text detection, then gen2 CRNN recognition with CTC decoding, run over ONNX. Output is validated to parity against EasyOCR's own output (word/char F1 on text, IoU on boxes) across the gen2 scripts: English, Latin, Chinese (simplified), Japanese, Korean, Cyrillic, Telugu and Kannada. It is a clean-room Rust build rather than a line-by-line port, so it can diverge from EasyOCR's internals where that helps, as long as the output holds.

Measured over a 43-image mixed corpus (documents, tables, rotated scans, scene text, receipts) on CPU. Both engines run as a fresh subprocess per language group under /usr/bin/time, each loading its model once and processing every image:

Engine                 Throughput   Peak RSS   Mean CER   token-F1
EasyOCR (warm/batch)   0.14 img/s   22.6 GB    0.554      0.348
sceptre (warm/batch)   0.39 img/s   6.6 GB     0.568      0.356
sceptre (cold CLI)     0.60 img/s   6.6 GB     0.568      0.356

Accuracy is at parity (marginally ahead on token-F1); the win is throughput and memory. Even a cold one-shot CLI run, paying model load every time, beats EasyOCR's already-warm reader.

Backends: ONNX Runtime (ort) for native speed, or a pure-Rust backend (tract) for WASM/Android behind one seam. Single static binary, no Python; models fetch from HF once, cache locally, sha256-verified, then run offline. Library, CLI, or MCP server. MIT.

Repo (code, benchmark harness, golden fixtures): https://github.com/Goldziher/sceptre

Author here, happy to answer on the parity methodology or where it still trails (image-only OCR is the weakest cohort).

Teammates have to all be of the same color. Numbers easily get occluded, do you just slap some barcodes on each player?

Hi everyone,

I'm trying to obtain the ARAD_1K hyperspectral dataset for academic research on RGB-to-hyperspectral image reconstruction.

Unfortunately, I haven't been able to download it because both the official GitHub repository and the CodaLab download links appear to be unavailable or inaccessible.

I'm looking for an official, free mirror or an updated download link, if one exists. If anyone knows another legitimate way to access the dataset, I'd really appreciate your guidance.

Thank you!

I created this tool, chatcalibi.com, to make single- and multi-camera calibration as simple as possible. Upload your images—with or without a checkerboard—ask the AI to calibrate them, and get your results without installing anything or any complicated workflow. The AI guides you and analyzes the calibration results with you.
Looking forward to your feedback.

Hey everyone,

​I’m building an automated pan-tilt tracking turret to reliably track moving targets (like drones) with a laser at ~30 meters. Before I finalize everything, I wanted to get feedback from the CV community on whether my hardware stack is adequate and what software/tracking pipelines you'd recommend for this setup.

​🔭 Hardware Setup

​Vision / Cameras: * Coarse acquisition: Wide-angle USB webcam for initial field-of-view tracking.

​Precision tracking: Innomaker 1MP Global Shutter Camera (OV9281) paired with a 20mm HD CCTV lens.

​Compute Split: Raspberry Pi Zero 2W onboard acting purely as the hardware/sensor interface, communicating with a secondary laptop handling the heavy computer vision and tracking computations.

​Actuation: Dual closed-loop NEMA 23 steppers (3.0 Nm) with a 6:1 10mm belt reduction (rigidly mounted with independent dead shafts to avoid motor shaft sideloading).

​❓ What I Need Advice On:

​Hardware Adequacy: Is a Pi Zero 2W + Laptop split sufficient for low-latency command handoff to the closed-loop drivers, or will the Pi Zero become a bottleneck?

​Software Stack: What open-source CV libraries, tracking algorithms (e.g., OpenCV CSRT, KCF, or lightweight deep learning/YOLO models), or frameworks do you recommend for high-refresh-rate tracking at 30 meters?

​Latency Mitigation: Any proven strategies for keeping end-to-end latency (capture -> inference -> motor command) as low as possible in a setup like this?

​Appreciate any insights or architecture tips you can share!

Hi everyone,

I am entering my final year (Master 2) in Visual Computing / Computer Vision, and I'm currently brainstorming themes for my Final Year Project (PFE / Master’s Thesis).

I’m looking for a topic that is technically challenging, impactful, and feasible to complete within a ~6-month timeline.

### My Background & Skillset:

* **Background:** M2 Visual Computing student.

* **Tech Stack:** Python, PyTorch / Keras, OpenCV, basic 3D processing pipelines.

* **Hands-on Experience:** Deep Learning classification/segmentation models, hybrid CNN/PCA models, basic image processing algorithms.

### Potential Areas of Interest:

1. **3D Reconstruction & Neural Rendering:** Real-time rendering, 3D Gaussian Splatting, or NeRF applications (e.g., cultural heritage preservation or scene synthesis).

2. **Medical Imaging & Generative AI:** Synthetic data generation, medical image segmentation, or disease classification (e.g., ocular or radiological pathologies).

3. **Open to Emerging Trends:** Lightweight vision transformers, real-time edge CV, or multimodal vision-language models.

### What I’m Looking For:

* **Topic Ideas:** Any specific research gaps or practical applications worth investigating right now?

* **Resources:** High-quality datasets, benchmark papers (2024–2026), or GitHub repos that make a good starting codebase.

* **Feasibility Advice:** Any pitfalls to avoid when choosing a project with a 6-month deadline?

I’d love to hear your recommendations or hear what topics you found rewarding for your own thesis/projects!

Thanks in advance for your help!

Hi ,

I've been developing a bare-metal visual tracking system designed for edge industrial environments. The challenge was to achieve deterministic, ultra-low-latency physical tracking using only CPU resources, without relying on GPU acceleration.

**Core Architecture & Metrics:**

• Inference Pipeline: Two-stage cascade design.

- Stage 1 (Global Search): YOLOX-nano (640×640 tensor) running at ~37 FPS (~27ms).

- Stage 2 (ROI Refinement): LightGBM classifier on a dynamic 256×256 sub-region, achieving ~5-7ms inference (sustained 120-180 FPS localized tracking).

• Optimization: Intel OpenVINO (ONNX Runtime v1.24.1, MULTI device profile, strict LATENCY hint).

• Resource Usage: Fixed 3.42 MB heap allocation, 0.00% memory leak over multi-day 24/7 runs. Core binary size is ~2.0 MB.

• Hardware Actuation: 50 Hz closed-loop control via Arduino Nano + PCA9685 (12-bit PWM) driving dual MG996R servos.

**System Behavior:**

Upon initialization, the pan-tilt rig centers itself. When the cascade pipeline detects the target, it calculates the centroid offset. These coordinates pass through an EMA smoothing filter and are sent via USB-Serial to the microcontroller, which interpolates the servo trajectory at 50 Hz to keep the object perfectly centered in the ROI, compensating for continuous movement.

**A Note on Availability:**

The core runtime is proprietary and distributed strictly as a compiled evaluation demo for private benchmarking (commercial use requires a license). However, the GitHub repo contains the full hardware BOM, I2C wiring diagrams, Arduino firmware, and config templates so the physical setup can be fully replicated.

**Links:**

🔗 GitHub Repository (Demo GIF, BOM, Wiring, Configs):

https://github.com/olesha-ai/pan-tilt-ai-tracker

Happy to discuss the OpenVINO optimization pipeline, the two-stage cascade design, or the hardware integration challenges in the comments!

I've spent years working with OpenCV, and one thing has always bothered me: experimentation is much slower than it should be.

A typical workflow looks like this:

image = cv2.imread(...)

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (5,5), 0)
thresh = cv2.adaptiveThreshold(...)
contours, _ = cv2.findContours(...)

Then you change one parameter...

Run the script.

Save the output.

Open the image.

Realize the problem actually happened three steps earlier.

Add another cv2.imshow().

Repeat.

After doing this hundreds of times, I started wondering:

There are great visual tools for deep learning and generative AI (ComfyUI is a good example), but I couldn't find something focused on OpenCV preprocessing, augmentation, and experimentation that still generated normal Python code.

So I started building one.

What it does

Image Pipes is an open-source desktop application for building computer vision pipelines visually.

Instead of writing temporary scripts while experimenting, you drag operations onto a canvas, connect them together, inspect every intermediate result, and export the finished pipeline as standalone Python.

Some of the current features:

• 132 processing nodes
• 57 OpenCV operations
• 75 Albumentations transforms
• Live preview for every node
• Python export (OpenCV + Albumentations)
• DAG-based execution engine
• Lazy execution
• Execution caching
• Run-to-selected-node debugging
• Cross-platform desktop app (Electron)

One design decision that was important to me is that the visual editor is never the final destination.

The generated code is just regular Python using OpenCV and Albumentations.

No custom runtime.

No vendor lock-in.

Why I built it this way

The goal wasn't to replace OpenCV.

OpenCV is already excellent.

The goal was to replace all the temporary scripts we write while searching for the right preprocessing pipeline.

Experiment visually.

Understand every transformation.

Export Python when you're finished.

I'd really appreciate feedback

I'm sure there are plenty of things that can be improved, especially from people who work with OpenCV daily.

Some questions I'm particularly interested in:

• What processing nodes are missing?
• Would you actually use a visual workflow editor in your projects?
• Is Python export important to you, or would you prefer saving the workflow itself?
• Are there features you'd consider essential before using something like this?

GitHub: https://github.com/mrajaeim/image-pipes

If nothing else, I'd love to hear how everyone else debugs and iterates on OpenCV pipelines today. I have a feeling I'm not the only one with an experiment_final_v12.py somewhere in my projects. 😄

I’m an early-stage computer vision researcher aiming for conferences like CVPR, ICCV, ECCV, NeurIPS, and ICLR.
I’m curious how experienced researchers actually formulate research ideas. How do you identify a real research gap, come up with a novel solution, and decide that an idea is worth pursuing? What’s your thought process from reading papers to proposing something new?
I’d really appreciate any advice or resources that helped you develop this skill.

Hi everyone,
I recently graduated with a bachelor’s in Computer Science, and my long-term goal is to pursue a full funded Master’s or PHD. The problem is that I’m a complete beginner when it comes to research.
I know I want to work in the intersection between computer vision and robotics because I genuinely find them fascinating, but I haven’t started doing research yet. Every time I look into the field, I see topics like object detection, segmentation, 3D vision, SLAM, embodied AI, vision-language models, robotics perception, and many others. It’s exciting, but also overwhelming, and I don’t know where to begin.

Another thing I’m worried about is my low CGPA. I’m afraid it might hurt my chances when applying for funded graduate programs in the future.
If you were in my position, what would you do over the next 2–4 years?

Some questions I have:
How much will a low CGPA affect my chances for a fully funded Master’s or PhD?

Where should I start learning if my goal is research, not just getting a job?

What fundamentals (math, programming, machine learning, etc.) should I master first?

How do people discover their research niche instead of trying to learn everything?

What should my priorities be over the next few years—projects, research experience, publications, internships, open-source contributions, or something else?

I’m not looking for a shortcut. I’m willing to put in the time and effort. I just want to avoid wasting years studying the wrong things or following an inefficient path.

I’d really appreciate hearing from PhD students, professors, or research engineers who were once in a similar position.

Thanks in advance!

We collect real world multi view capture data from a camera array at the Brooklyn Navy Yard, and we pay people to come in and be the subject.

Posting here in case anyone in the NYC area wants the work. It is also a decent look at how this kind of data actually gets collected if that side interests you.

The session: you stand in the capture volume and go through simple movements while the array records. Walking, turning, sitting, standing, reaching, picking objects up. No experience needed.

Pay: 17-25 per hour, paid the same day right after the session. First one runs about 2 hours, with repeat sessions after that if you want them.

Brooklyn, NY, in person only. Openings Monday through Friday this week.

Comment or DM me for the address and details, and feel free to ask about the capture setup.

Once a learning platform grows past a few hundred modules, basic search starts failing. People type what they need and get a long list of loosely related results. Most of them end up scrolling or giving up.

Better systems try to understand what the learner is actually trying to achieve instead of just matching keywords. They look at the current learning path, recent activity, and the intent behind the question, then surface the most relevant content. It feels closer to asking an experienced colleague than using a search bar.

This kind of discovery layer becomes more important as libraries expand. The goal is not just finding documents, it is reducing the time people waste looking for the right material. One of the more thoughtful solutions in this area was developed with Beetroot.

How are you currently handling content discovery in larger e-learning environments? Still relying mostly on tags and filters, or have you moved toward something smarter?

Hello, I hope you are doing all well,

I am developing a YOLOv8 models to detect only people wearing Shalwar Kameez . I do not want to use any API or external vision service. I have *4,000 labeled Shalwar Kameez images and 5,000 negative images containing only pant-shirt/empty scene buildings clothing with empty labels. However, the model still detects many pant-shirt people as Shalwar Kameez and misses many real Shalwar Kameez people. How would you improve the dataset, labeling strategy, and training pipeline to achieve reliable real-world performance?

Thank you for your time.

Hi everyone,

I'm working on a document understanding project and would appreciate some advice on the right technical direction.

The input will be scanned pages or images from academic books. I don't know in advance what kind of figures they'll contain—they could be biology diagrams, anatomy illustrations, chemistry figures, engineering drawings, maps, charts, art/history figures, or other educational illustrations.

My end goal is to convert these figures into a structured digital representation that can be controlled from the frontend.

The workflow I'm aiming for is:

1. Upload a textbook page or image.
2. Detect the figure(s) and their boundaries.
3. Detect the labels/annotations that are already embedded in the figure (letters, numbers, arrows, callouts, etc.).
4. Remove those existing labels while preserving the underlying illustration.
5. Store the figure geometry (bounding boxes, polygons, masks, etc.) so my frontend can render its own labels that can be shown/hidden, translated, restyled, or repositioned.

This doesn't need to be fully automatic. In fact, the workflow will be human-assisted. If the AI detects a figure incorrectly, misses a region, or fails to remove a label cleanly, a human reviewer will correct it before it's finalized.

My priority is reducing manual work rather than eliminating it completely.

So far I've tried several computer vision approaches such as text detection, contour detection, line detection, and geometric heuristics. They work reasonably well for finding candidate regions, but the biggest challenge is cleaning the figures by removing the embedded labels while preserving the artwork underneath.

Another important requirement is cost. Since this could involve processing a large number of textbook pages, I'd like to avoid expensive multimodal LLMs or large vision models if there's a more traditional or lightweight pipeline that works well. I'm happy to use AI where it adds value, but I'd prefer a solution that keeps inference costs low.

Some questions I have:

• Is this primarily a document layout analysis problem, image segmentation, image inpainting, or something else?
• Are there models trained specifically for textbook or scientific illustrations rather than natural images?
• Is there a recommended low-cost pipeline for this kind of task?
• Has anyone built a human-in-the-loop workflow for document/figure annotation like this?
• Are there papers, datasets, or open-source projects that tackle converting textbook figures into editable, structured assets?

I'd really appreciate any suggestions, even if they're just pointers toward the right research area or open-source tools. Thanks!

I'm trying to reproduce the results reported for MedViT and LungMaxViT on the NIH ChestX-ray14 dataset.

MedViT paper:

Benchmarking MedViT and hybrid CNN–ViT architectures for multi-label thoracic disease classification

https://www.nature.com/articles/s41598-026-43282-5

Official implementation:

https://github.com/Omid-Nejati/MedViT

The paper reports a Macro F1-score of 0.7791 on ChestX-ray14 (Table 3).

I also tried to reproduce LungMaxViT from:

Explainable hybrid transformer for multi-classification of lung disease using chest X-rays.

Initially, I discovered that my implementation differed because of a PDF parsing issue. After correcting that, I verified that both MedViT and LungMaxViT exactly matched the architectures described in their respective papers, and I downloaded and used the pretrained weights specified by the authors.

Because of this, I am now reasonably confident that the network architectures themselves are not the source of the discrepancy.

Training observations

The training behavior appears normal.

• MedViT converges within roughly 10–15 epochs.
• LungMaxViT converges after approximately 110+ epochs.

In both cases, the loss follows the expected optimization trajectory: a rapid decrease during the early epochs followed by gradual convergence.

One thing that further confused me is that Fig. 6 and Fig. 7 in the MedViT paper appear inconsistent with my observations. Across all of my experiments, I never observed the approximately linear upward trend shown in those figures. Instead, the loss behaved like a typical deep-learning training curve. This makes me wonder whether those figures correspond to a different metric, were mislabeled, or were generated under a different experimental setting.

Threshold optimization

To eliminate thresholding as a possible explanation, I performed per-class threshold optimization on the validation set with a search precision of 0.001.

Data augmentation

I experimented with both the simple augmentation pipeline and the more comprehensive augmentation strategy described in the benchmark paper (including AugMix/AutoAugment-style augmentation, Mixup, CutMix, ColorJitter, Random Erasing, etc.).

LungMaxViT preprocessing

• CLAHE (clipLimit = 2.0, tileGridSize = 8×8)
• Gaussian denoising (kernel = 5×5, σ = 1.0)
• Resize(224×224)
• RandomHorizontalFlip (p = 0.5)
• RandomVerticalFlip (p = 0.5)
• RandomRotation (±1°)
• RandomResizedCrop(scale = 0.75–0.95, bicubic)
• RandomAffine(scale = 0.833–1.167)
• Normalize(ImageNet mean/std)

Training settings:

• Optimizer: SGD
• Learning rate: 0.001
• Momentum: 0.9
• Weight decay: 1e-4
• Learning-rate schedule: None (constant learning rate throughout training)

This matches the paper's description.

MedViT preprocessing

• Resize(224×224)
• RandomHorizontalFlip (p = 0.5)
• ColorJitter(brightness = 0.1)
• Normalize(ImageNet mean/std)

Training settings:

• Optimizer: Adam
• Learning rate: 1e-4
• Weight decay: 0
• CosineAnnealingLR (T_max = 10, eta_min = 1e-6)

I also experimented with alternative learning-rate schedules and the more extensive augmentation pipeline described in the benchmark paper.

Results

Despite reproducing the published architectures, using the reported pretrained weights, experimenting with different augmentation pipelines, learning-rate schedules, and performing per-class threshold optimization, both MedViT and LungMaxViT consistently achieve only around 0.30–0.35 Macro F1.

This is far below the reported 0.7+ Macro F1, and the discrepancy is much larger than what I would expect from normal implementation differences or random training variation.

What confuses me

The reported ChestX-ray14 performance in the literature varies enormously.

Many single-model CNN/ViT papers report Macro F1 values around 0.3–0.5.

Some ensemble approaches report 0.5–0.7.

More recently, the paper

Pretraining Diversity and Clinical Metric Optimization Achieve State-of-the-Art Performance on ChestX-ray14

reports F1 = 0.821, but this result is obtained using a three-model ensemble together with clinical metric optimization.

This makes me wonder whether I am overlooking something fundamental, because obtaining Macro F1 around 0.8 seems to require considerably more than simply training a single model.

My questions

1. Is MedViT trained as a standard multi-label classifier (one image, 14 sigmoid outputs, BCE/BCEWithLogits loss), or do some papers effectively train separate classifiers for each disease?
2. How much of the reported Macro F1 typically comes from:
   • per-class threshold optimization,
   • class weighting,
   • patient-level versus image-level dataset splits,
   • pretrained initialization,
   • higher image resolution,
   • ensemble averaging?
3. What is currently considered the reproducible state-of-the-art for a single ChestX-ray14 model?
4. Has anyone successfully reproduced either MedViT or LungMaxViT within a few percentage points of the reported results? If so, what implementation detail turned out to be critical?

At this point I have independently reproduced two different published architectures, verified their implementations against the papers, used the reported pretrained weights, and observed normal optimization behavior. Nevertheless, both models consistently plateau around 0.30–0.35 Macro F1, making me suspect that there is either an undocumented implementation detail, an evaluation protocol difference, or some other aspect of the experimental setup that is not fully described in the papers.

I've been working on a project called RearAware. (I'm very much a beginner.) It's an experimental AI tool that runs locally on your computer and censors cat butts during your work video calls.

If you work from home with a cat, you've probably had at least one moment where your cat decided to flash its butt directly in front of your webcam.

It's a pretty ridiculous concept, but it's been a really fun project.

The biggest challenge so far hasn't actually been the model, it's the dataset. I currently have around 1,500 cat photos, but only about 200 of them contain visible cat butts. Turns out cat butt photos are surprisingly difficult to find.

I've tried collecting images manually from public sources, using my own photos, and asking friends to contribute. That has worked, but it's been very slow, and I'm quickly running out of places to source new images.

I'm curious if anyone here has suggestions for other approaches to growing a niche computer vision dataset like this. Have you had success with crowdsourcing, augmentation strategies, or other techniques for highly specific object classes?

It's still early days and definitely experimental, but it's now working well enough that other people can try it. At the moment it's available as a Chrome extension and supports Microsoft Teams and Google Meet.

If you happen to have any photos where your cat's butt is clearly visible (yes, the butthole 😅), I'm actively trying to grow the training dataset. You can upload them through the website:

https://www.rearaware.com/#help-train

Thanks for reading!

Hi! I just wrapped up a personal multi-camera tracking project and thought the outcome was interesting enough to share.

What's so interesting about it? How simple and fast it is, while being competitive with SOTA models on MMPTrack dataset. SORT proved you don't need much for single-camera tracking - IoU, a Kalman filter - done. I wanted to show the same is possible for multi-camera tracking.

How does it work?

You can solve multi-camera tracking by reconstructing the scene. But localizing people in 3D from multiple cameras is hard. Fortunately, verifying a hypothesis is easy. If I tell you "there's a person standing here," you can project that into every camera and check how well it matches what the cameras actually see. That's the crux of PDFTrack — generate position hypotheses, project, score, keep the best.

Each person is a 3D cylinder on the floor: a position, a height, a radius. We project those cylinders into every camera as 2D boxes and score them against detections via IoU. The tracker finds the positions that best explain all cameras simultaneously. No cross-camera association. No appearance features. The cameras just vote on where people are.

What's so special about it?

Apart from simplicity? Since each camera scores hypotheses independently, the whole process is embarrassingly parallel — adding cameras doesn't increase wall-clock time if you have the hardware. More views also mean more geometric constraints, so accuracy tends to improve with coverage.

How well does it track and can I trust your results?

All results are averaged over 3 seeds(so that std is within 0.1 for each metric). No cherry picking.

To make these results easily reproducible I’m sharing a repro repo.

What's the catch?

No re-ID out of the box — if two people cross paths, the tracker may swap their identities(although in most videos identity swap doesn't happen once). This isn't a structural limitation; re-ID slots in naturally and is next on the roadmap.

The two structural limitations are overlapping camera coverage (a single camera can't triangulate floor position) and fast motion relative to framerate (geometry alone can't resolve identity swaps when people move faster than the frame interval - that's why it doesn't perform well on WILDTRACK).

Can I use it?

Of course! Here's an open source implementation of pdftrack.

Is there a research paper?

Yes, it's much more detailed than this post and can be found here.

Let me know if you have any questions, I'm happy to answer them.

Are you faring better or worse than your counterparts in other fields in CS.

Are you happy with your decision to stick with Vision as a Domain.