Has anyone seen any of the common libraries being reverse engineered? Keyence, Cognex, Halcon?

Sendly is an iOS app that scans a bouldering wall and tells colorblind climbers which holds belong to their route. Here's how it recognizes holds, all on-device with no server:

Hold detection and segmentation: an RF-DETR-Seg (Large) model at 768 px, fine-tuned on climbing walls (my own gym photos plus openly licensed datasets), converted to Core ML. It outputs a mask for every hold and volume, in about 0.9 s per scan on the phone.

Color classification: each hold's mask is turned into 48 color features, and a random forest labels its color.

Route grouping: holds are clustered into routes per photo, based on color and position, then each route is named. Users can choose a colorblind type (protan, deutan, tritan or achromat), and the app remaps the display palette, gives each route a distinct shape, and warns when a wall has colors that are easy to confuse.

Manual fixes: if the model misses a hold, tapping it runs SAM 2.1 tiny (Core ML, about 100 ms per tap) to segment it.

Where it struggles (I'd love ideas):
Detection is solid, but color is the weak spot, at about 82% per hold. The main confusions are pink vs red, black vs gray on dark walls with chalk, and orange/salmon/brown. Adding more labels didn't help, which suggests the per-hold random forest has hit its limit. Next I'm considering relative color within the same photo (normalizing against the other holds) or a small CNN on hold crops.

Has anyone solved color under uneven indoor lighting?
If anyone has any suggestions i would love to hear 🙌

Greetings everyone, programming isn't my strong suit; I'm a civil engineering student. However, this is part of a study for pedestrian bridges, so I would appreciate any ideas you can give me for this problem. I have limb detections of a person walking on a treadmill while wearing a light suit. My input data consists of all the lights detected by a camera (including any noise or distortion).

That is, I have an x_Record and a y_Record, which are the respective coordinates of the detected lights. Both are n x m matrices.

n is the number of actual limbs, plus any noise detections. So, if I actually have 12 real points, my matrix could reach 30 points in some frames, the additional ones being noise.

And m is the number of frames, i.e., the time.

In my problem, points can appear and disappear due to occlusion or distortion. I manually classified 100 frames. I assigned a row to each limb, so row 1 will always be the head and row 9 the left knee, for example. That's what I need: to classify the location of each part of the person at all times.

I've come to this point because I've tried using minimum distance from the previous frame, and optimizing with lsqnonlin by varying angles and lengths. But nothing has given me good results, and I would appreciate help in figuring out the most optimal way to solve this type of problem. I have all the Matlab tools and toolbox available through my university, so I would prefer to use that language, but I'm open to other options if they facilitate the process.

Hi everyone,

I just want to share a project I was working on.

I called it PointRead. Basically, it lets you translate text by sliding your finger under it. It detects the text, translates it and speaks it through a speaker. I built it on an Nvidia Jetson Orin Nano with a Raspberry Pi Camera Module V2, and it works fully offline.

GitHub: https://github.com/striksio/PointRead

Video demo: https://youtu.be/xo0bdDjVpPQ

I like reading books, but I often need a translation for some of the words. Looking them up on my phone feels uncomfortable, because I want to read paper books without looking at a screen. So as a side project, I built this pipeline.

The way it works: index finger and thumb are used for activation, which is a double pinch. Then it tracks the index finger and the text above it. Once done, it extracts the text that was pointed at, recognises it, translates it and speaks it.

Pipeline

• RTMDet for hand detection and RTMPose for keypoints
• Adaptive Gaussian thresholding for text binarization (works better than Canny for this)
• Morphological close to merge text into single line regions
• PP-OCRv5 server model via RapidOCR (on CPU for now, because onnxruntime GPU isn’t available for Jetson r39.2 yet, so OCR is slow)
• Argos Translate for translation
• Piper for speech

Some details

• One-Euro filter for smoothing, because RTMPose keypoints are not stable
• Keypoints sometimes disappear, so they’re kept for several frames
• Sliding only goes forward (left to right), and once you move to the next line it won’t jump back to the previous one

It can run headless with only a speaker, or with a local web server for debugging.

Limitations

• OCR runs on CPU only, as mentioned above
• The book needs to be positioned with horizontally aligned text
• As shown in the demo, text detection fails sometimes
• Books with huge fonts or wide spacing can fail to form a line

Thank you for your time, and I would love to hear some feedback about this, thanks!

One thing that always bothered me about computer vision resources is how much attention goes into architectures and benchmark scores, while the fundamentals behind those numbers often get overlooked.

A model can achieve impressive mAP and still fail because of dataset leakage, camera noise, distribution shift or an evaluation protocol that doesn’t reflect its actual use case.

So I organised the repository into 16 sections, covering image formation, classical geometry, datasets, evaluation, CNNs, ViTs, self-supervised learning, detection, segmentation, video, 3D vision, generative models, VLMs, deployment and robustness.

A few principles behind it:

• Primary sources only: original papers, specifications and official documentation.
• Resources arranged in dependency order, so each section builds on the previous ones.
• Evidence-backed claims rather than blindly repeating benchmark numbers.
• A reproducible benchmark for every section, connecting the theory to actual measurements.

The idea is to understand not just how computer vision models work, but why they fail and what it takes to make them reliable.

It’s free and open source:

https://github.com/usamahz/computer-vision-engineering

Would appreciate feedback, particularly from people working on vision systems in production. What important topics or papers am I missing?

Hi everyone! We’re building Nuvo Vision One, a stereo depth camera powered by a Raspberry Pi 5, and wanted to share where we’ve got so far.

This started from our own need to add depth sensing to our products. The stereo cameras we were considering were expensive for our budget, and we already had a Pi 5 handling compute. We wondered how far we could get by connecting two cameras and doing the stereo processing on the Pi itself.

The setup uses two IMX296 global-shutter cameras with a shared hardware trigger to synchronize capture. The Pi handles image rectification and stereo matching, producing disparity and depth alongside the camera images.

Doing this on an SBC comes with limits. Resolution, frame rate and matcher settings all affect how much work the Pi can keep up with. We’ve reached a useful starting point for our needs, but there’s still plenty to improve. The attached preview video shows the current output, including the holes and noisy regions where matching struggles.

We also built a browser-based interface to make it easier to use. You can preview the images and depth, adjust exposure and stereo settings, choose outputs, and work through calibration. It’s accessible over the local network through Ethernet or Wi-Fi.

One reason we like this approach is that the camera’s compute is also a normal Linux computer. You can modify the image pipeline and run your own applications on the same Pi. The Nuvo Depth software is open source, including the runtime, web interface and SDKs.

We’ve put product photos and web UI screenshots in this album so you can see the hardware and controls alongside the video.

We’d love feedback from people working with stereo vision or robotics. What would you want to test first, and what would make something like this useful in your projects?

GitHub: https://github.com/arputhamips/nuvo-depth

I have 2 years of work experience, currently working as GenAI engineer but hoping to get Computer Vision roles.

Job applications are getting constant rejections. Don't know if the problem is in the resume or the experience.

What changes / projects would you suggest to get noticed / shortlisted by companies?

Thanks in advance for the suggestions

Longer version with animations: https://blogs.fablnx.com/posts/every-colour/

Showcase of something we built at work. It's a narrow tool, but I think it could be useful to other people too.

Some context. We're building AI that reads construction drawings and turns them into steel models. A person has to sign off on every beam in that model, so we want every piece of it to trace back to exact shapes on the drawing. The very first step is splitting the rendered drawing into regions: touching pixels with exactly the same RGB colour. A full sheet at 800 dpi is about 806 MP and has around 1000 colours because of anti-aliasing, and every region has to come out exactly right.

We already run our own models on our own GPUs, so we wanted this step there too. We didn't know about cuCIM at the time. The first thing we tried was NVIDIA's NPP (nppiLabelMarkersUF). It was slower, and its labels changed from run to run on the same image, which looks like a bug. We reported it to NVIDIA with a 3x3 example, it's here if you use NPP: https://github.com/Acero-AI/npp-labelmarkers-bug

So we wrote our own: a union-find labeller written in CUDA C++ for NVIDIA GPUs and in Metal for Apple GPUs, so it also runs on a MacBook. Later we found cuCIM, which is really good, and copied one trick from it (the order neighbours get joined in) that made ours a lot faster.

Where it ended up:

- NVIDIA A100: the full 806 MP sheet in 49 ms with the image already on the GPU, about 300 ms with the copies. 2.7x faster than cuCIM on the full sheet, up to 19x on small images where cuCIM's per-call overhead dominates.
- Apple M5 Pro MacBook, through Metal: 151 ms, against 2.6 s for cc3d on one CPU core.
- The output matches cc3d exactly, numbered the same way, so you can check it on your own images.

Using it:

pip install "colorcc[cuda12]" # or [cuda13]. On a Mac just: pip install colorcc

import torch, colorcc
img = torch.from_numpy(rgb).to("cuda") # [H, W, 3] uint8, use "mps" on a Mac
labels, n = colorcc.label(img, conn=8, ignore=(255, 255, 255))

It should work for anything made of exact colours: rendered drawings and diagrams, segmentation masks saved as RGB, palette images.

Limits, so you can rule it out quickly: 2D uint8 RGB only (use cc3d for 3D), exact colours only (JPEGs need cleaning up first), and it returns labels and a count, no stats. The benchmarks come from one mostly white test drawing.

cc3d and cuCIM are great general tools, this is the narrow case we needed.

Code (MIT): https://github.com/Acero-AI/colorcc

(Disclosure: I am part of startup that built it, Fablnx. The blog above is ours.)

I shipped a Linux x64 build of the same conveyor inspection demo I had on Windows (0.10.0 eval).

What it is: fixed 3×3 grid, quality (LightGBM ) runs only when the focused apple centre is in the centre cell C — not full-frame chase. YOLOX 640 + ROI 256 → 44 features → classify. Nim UI shell + three inference ".so" plugins + bundled ORT CPU.

Linux package: unzip "Fruit_Inspector_linux_x64.zip" from the existing release (no new tag — asset added to 0.10.0):

https://github.com/olesha-ai/fruit-inspector-demo/releases/tag/0.10.0

Target:Debian 12/13, Ubuntu 22.04+ x86_64. Built for SSE4.2 + AVX1 (AVX2 not required on this drop). USB UVC camera; "run.sh" sets "LD_LIBRARY_PATH". FAT USB gotchas are documented in the zip "README.txt".

Not: ARM/Pi yet; not commercial license (NC eval — read LICENSE in the zip).

Windows desk reference (same logic): still "Fruit_Inspector_DLL.7z" on that release.

If you try it: curious what "[infer]" fps you see on your CPU vs camera preview cap.

Part 1 / SMB angle (Medium):

https://medium.com/@olesha-ai/democratizing-ai-computer-vision-for-small-and-medium-business-516f840858b3

Same prompt. Different rust-mask errors.

I compared GPT Image 2.5 Sunburst and Nano Banana 2.1 on eight identical prompts to explore synthetic training data for rust segmentation. Both generated promising samples and masks with missing rust, shifted boundaries or false positives.

I then expanded the work to 502 image mask pairs, including the pilot. After visual screening, 400 remained and 102 were excluded: a 79.7% retention rate. That is an encouraging starting set for training, with room to expand it further.

Two engineering notes document the comparison and the larger review, with interactive mask overlays. RF-DETR training and real-image evaluation come next.

Part 1 — 14 October 2026: GPT Image vs Nano Banana, eight prompts and interactive mask comparisons.

https://www.antal.ai/blog/synthetic-rust-masks-gpt-image-vs-nano-banana.html?utm_source=reddit&utm_medium=social&utm_campaign=rust_segmentation_2026_10&utm_content=pilot

Part 2 — 16 October 2026: generation and dataset review — 502 inspected, 400 retained, 102 excluded.

https://www.antal.ai/blog/synthetic-rust-dataset-generation-review.html?utm_source=reddit&utm_medium=social&utm_campaign=rust_segmentation_2026_10&utm_content=review

#ComputerVision #SyntheticData #ImageSegmentation

Disclosure: I’m a coauthor of VideoScore2. I used AI assistance to prepare this summary.

A generated clip can look sharp while missing the requested action, or match the prompt while violating object persistence. Those are different evaluation failures. VideoScore2 evaluates visual quality, text-to-video alignment, and physical/common-sense consistency separately, with explanations alongside its evaluations.

For a practical inspection, keep the video file and its original generation prompt fixed. Run the released single-video inference script, then compare the explanation for each dimension with specific frames or transitions in the clip. The repository exposes --video_path and --t2v_prompt for this purpose and links the model, dataset, and demo.

A small diagnostic set could include (1) a visually degraded but otherwise faithful clip, (2) a good-looking clip with a prompt mismatch, and (3) a clip with an object-persistence or interaction failure. Label these cases by hand before comparing evaluator output, so an attractive explanation does not become the ground truth. This is a suggested inspection protocol, not a new experiment or reported result.

The model’s consistency judgment is not a physics proof; subtle temporal failures and unusual scenes still need human inspection. I’d be interested in concrete cases where these dimensions disagree, and how you test whether an evaluator is responding to the intended failure rather than image quality alone.

Paper: https://arxiv.org/abs/2509.22799

Code, model, dataset, and demo links: https://github.com/TIGER-AI-Lab/VideoScore2

The paper and code are free to access; local or cloud inference may incur compute costs.

Hey everyone!

I'm putting together a small, serious team for More Than a Hack 2027, a football analytics competition organized by Barça Innovation Hub, Metrica Sports, and Mobile World Capital Barcelona.

A little about me: I'm a 4 year experienced AI engineer . I'm also passionate about football, and I want to approach this as a genuine engineering and research challenge rather than just another weekend hackathon.

About the competition

The first challenge involves estimating ball possession from real FC Barcelona match footage, automatic player/ball tracking, and tactical event data. The top 20 teams advance to a broader football analytics innovation challenge, with five teams eventually pitching in Barcelona.

Who I'm looking for

I'm mainly looking for people around my age and experience who are genuinely passionate about football and interested in learning and building together. You don't need to be a professional ML engineer, Computer Vision engineer, or data scientist. Experience is welcome, but curiosity, reliability, and the willingness to put in consistent effort matter more.

You might be a good fit if you have:

• An interest in football tactics, analytics, or technology
• Some experience with Python, machine learning, Computer Vision, data analysis, or software development
• A background in another relevant area and the motivation to learn
• The ability to commit time, communicate well, and contribute consistently

I'm especially interested in people who are willing to research before implementing, experiment seriously, and put in the hours even if they are still developing their technical skills.

How I want us to work

I want a team that researches before implementing, challenges assumptions, measures results, documents experiments, and takes ownership.

I'm absolutely fine with AI-assisted coding. I just don't want our entire approach to be prompt-driven without understanding the underlying problem.

Ideally, everyone can contribute around 10–12 focused hours a week during the initial challenge and stay committed if we qualify for later stages. You don't need to be an expert, but you should be able to make a genuine commitment and follow through.

The team will be remote and international. The official team size is 3–5 members.

Interested?

Send me a DM with:

• Your background, interests, and what you'd like to contribute
• GitHub, LinkedIn, relevant publications, or previous projects, if available
• Your time zone and realistic weekly availability
• A brief thought on how you'd approach the possession-detection problem

I'm aiming to build a collaborative, technically strong team where everyone contributes, learns, and takes the competition seriously. If you're passionate about football, willing to learn, and can commit the time, I'd be happy to hear from you.

Competition: https://landing.mobileworldcapital.com/more-than-a-hack-2027

Technical repository: https://github.com/metrica-sports/more-than-a-hack-2027

Hi! I’m submitting “A Post-Processing Adapter for Correcting False Positives and False Negatives in Egocentric Hand Detection” to arXiv under cs.CV. If you’re eligible to endorse, I’d appreciate your help:

Endorsement link

Thanks!

It seems like object detection is more widely adopted, while skeleton and keypoint detection can capture finer-grained information about movement, pose, and interactions. I’m curious where this extra detail is proving useful in real-world applications, particularly in areas like AR/VR, robotics, manufacturing, and healthcare. Are custom keypoints and temporal annotations being used in production, or are most applications still research-focused? I’d love to hear about real-world use cases, where existing models fall short, and what annotation workflows look like in practice.

Thanks!

I documented an iToF depth sensor + Pi camera bring-up and calibration experiment in EP14 of my build series. We got a real pointcloud, then improved the calibration error from 12.7 to 4.56 px. That still misses our target of less than 4 px.

The important limit: a better calibration score does not establish correct RGB-to-depth alignment across the scene, and shared-clock synchronization is still missing. The episode includes the hardware failures and remaining gaps.

The one-box sensor shown in the thumbnail is a concept render; this test uses separate hardware. Under $100 is the goal, not a demonstrated product price.

For validating this setup, what held-out scenes or checks would you use to distinguish calibration error from timing and visibility/occlusion problems? Full experiment in the linked video.

I thought after working on CV at JPL I would be able to get a few more responses, but even when it seemed that the job descriptions matched my work very closely I still didnt get responses. This goes for both big companies and startups/smaller companies.

Questions:

1) Is an MS/PhD "required" to land perception roles at places like Waymo, Zipline, Wing, Figure, etc? Is it possible to be competitive as an undergrad?

2) Does my resume clearly communicate my experiences, what are some weaknesses I can improve on?

2) Any advice on getting my resume to recruiters or smaller startup teams?

Context:

- Applying for Winter/Spring/Summer 2027 internships

- 2nd year undergraduate CS student at UC Davis/Santa Barbara/Irvine, planning on graduating 1 year early, but considering an additional quarter just to land something or maybe go to grad school

- I'm still working at JPL through the Fall quarter and we hope to publish our work

- The bullet points for JPL are slightly redacted summaries, I have added more metrics and technical details on my real resume

- I have applied to ~50 robotics/autonomy/computer vision intern roles with 0 responses

I would appreciate any and all feedback, thank you so much!

Does anyone have the author kit for CVPR 2027? The official website doesn't seem to have it yet, unlike in previous years. Please correct me if I'm wrong.

Hi i am working on video generation pipeline biggest bottleneck i face it's take most time in saving video framws i save each frame by frame as it output from pytorch model so what best appraoch or liberay to less time saving?

Guys my first visa application was rejected but I did obtain new documents which kind of fulfil the reasons stated in the refusal letter.

The problem is tho I have worries regarding riots going on in Europe (mostly france and Italy for now but who knows)

Is there some way my paper isn't affected if no author can be physically present there? Is there a way of presenting online? Although I have already paid the amount for registration and for the attending thing (the 650 pounds they ask for). I don't intend to receive a reimbursement anyways, I just want to see if there are options apart from physical attendance and what will happen to my paper.

Please help me out.

hi i am currently participating in a competition but i am hard time finding a solution .
how can i create a mask where only pillars and other gray blocks are left with are converted to either Black or White

BMVC 2026 - Do papers accepted as oral typically also get allotted a poster session? The conference attendance page seems to indicate that orals will not have poster sessions but authors are welcome to upload an e-poster for online proceedings. Is this a characteristic of previous years as well? It would have been very helpful to have a poster session since that is where authors actually get to interact with attendees who want to engage with their work.