Join us on Nov 5 for the Visual AI in Agriculture virtual Meetup! Register for the Zoom.

Talks will include:

• U-Net Framework for Micro-Scale Surface Damage Segmentation in High-Resolution Soybean Seed Imagery - Saurav Upadhyaya at Louisiana State University
• From camera to drone: wildfire detection and integration at the edge - Maxime Carriere at kernwerk
• 5,000 Flights to Answer One Question: Can a Drone Sample as Well as a Human? - Rohan Talwadia at LabGPT

Left is the photo, right is Depth Anything's depth map. Same performer in a faceted mirror suit, shot outdoors in uncontrolled light — LA River concrete channel, under a bridge, desert hillside, hilltop at sunset.

The model finds the person in all four. Everything behind him is where it falls apart: the river and concrete wall flatten into a gradient, the bridge scene gets a black void where sky should be, the hillside turns flat and the suit collapses into a blob, the mountains become a flat black wall.

So the question for people who actually run these models: is this a specular problem, a background problem, or both? What breaks first in your stack — highlight blowout, or the geometry behind the reflection?

I shot the full set for exactly this failure mode. Details in the first comment.

I used a RealMan ECO65’s motion to calibrate an iPhone on its wrist and a fixed 320×240 iToF sensor in my home lab.

For the wrist camera, feature matches across 26 poses gave 9,456 triangulated points and roughly 2 px median reprojection error. For the iToF sensor, I averaged 10 frames per pose, isolated pixels changed by the moving arm, and fitted those points to the robot mesh with ICP. The median fit residual was 7 mm; independent accuracy still needs checking.

The recorded RGB, depth, IR and joint streams replay together in the office twin. Phone-estimated depth is the weak part: only 6/20 frames passed the held-out check. The room splat is static.

EP20, with the setup and failures: https://www.youtube.com/watch?v=HMC7yu18qdQ

I made the video. The experiment footage is real; narration uses my own AI voice clone and the thumbnail is AI-edited from my hardware photo and room scan.

Hey everyone!

Just built my first python engine as a 14 yo. It's a plant disease diagnostic engine designed to detect early-stage crop stress before any visual symptoms occurs.

Here's the repository https://github.com/adhrit1207/CropPulse

Would really like to have your thoughts on it.

Hi! I'm a materials engineering PhD researcher at the University of Sheffield, specialising in microscopy and microstructural characterisation. I'm looking for collaborators, particularly those with ML experience, for the upcoming hackathon (15–17 December).

Anyone interested in teaming up?

https://kaliningroup.github.io/mic_hackathon_3/

What’s the real bottle neck when you start a company for enterprise level or any business?

I’m thinking of supplementing my knowledge by watching talks and reading CV papers. I have no idea how to guide a CV research project to completion or what a CV engineer does first when they approach a problem. I’m trying to figure out how the engineering pipeline even works. Any advice?

TypeSafe recently added a Box question type to Jev: you describe something in an image in plain words and get back one bounding box with a confidence. It’s closed and API-only, so I built an open version: LOCUS (Locate Once, Check Until Settled).

The weights are open (2B and 0.8B) and run on as little as X GB of VRAM.

The problem: VLMs normally write a box out as text, one token at a time. That’s precise but slow, about 18 steps per box. A small regression head can predict the whole box in one pass, which is fast, but the edges come out loose.

The idea: use both. The head makes a quick draft, then the same model checks every draft token in parallel and fixes the ones it disagrees with, repeating until nothing changes. The final box is exactly what the model would have decoded on its own, in about 5.6 steps instead of 18.

Results (RefCOCO / RefCOCO+ / RefCOCOg):

• Same weights, Acc@0.9 goes from 54.9 → 59.1 with verification
• +4.52 Acc@0.9 over Jag (strongest open regression-head model) at the same size and training budget
• 1.5x faster than vLLM decoding the exact same tokens

Use it on your own data: the released models are trained on RefCOCO, but you can fine-tune them on your own dataset (images, a description and a box for each). The repo covers full fine-tuning and LoRA, so a smaller GPU works too.

Limitations: a pure regression head is still faster, and since it’s trained only on RefCOCO it struggles with very small objects. Fine-tuning on your own domain is the fix there.

• Project page: https://muhammad-talha-ad.github.io/LOCUS/
• Code: https://github.com/muhammad-talha-ad/LOCUS
• Models: https://huggingface.co/MTalha2001/LOCUS-2B

Not affiliated with TypeSafe. Since Jev’s Box is API-only, I couldn’t evaluate it under the same conditions, so all comparisons are against open models. Happy to answer questions.

My mother runs a sound healing room, so I rebuilt my old ESP32-S3-BOX-3 chakra firmware as an app for Espressif's ESP-Mosaico (ESP32-S31, 2.16" 480 x 480 touch screen, microphone).

What it does:

* Hears a singing bowl, tuning fork or hummed tone and shows the chakra with symbol, note, frequency to 0.1 Hz and cents (a tuner ring fills as the tone settles)

* The whole screen fades to the chakra's colour, so it works without lamps; Philips Hue (local API), Home Assistant lights and WiZ bulbs follow

* Two reactions: Flow waits 0.4 s for a steady tone and fades softly (made for a sound journey), Strike reacts in 0.13 s

* Notes (A = 440 or 432 Hz), Solfeggio, or your own bowls: strike each of your seven bowls once and it learns them

How it decides it is a tone and not noise: a 4096-point FFT (3.9 Hz bins, the old firmware had 31 Hz), a weighted harmonic sum, then three gates: loud enough, 45 % of the energy on the tone's harmonics, pitch steady within 35 cents. Plus hysteresis at note boundaries so a bowl sitting between two notes does not flicker.

I tested it against free recordings from Wikimedia Commons: single bowls and tuning forks lock one chakra 77 to 99 % of the time; drums, shakers, rain sticks mostly give no colour; a handpan melody changes colour 3 times in Flow and 116 times in Strike. One honest finding: real bowls are often not tuned to C to B. In a 7-bowl chakra video the "root" bowl rings at G#3 (210 Hz), which is why learning your own bowls exists.

The detection is plain C with no dependencies, so the board, Espressif's simulator (fed by the Mac's microphone) and the host tests run the same code. My board is still on order, so it is simulator-tested and builds for the ESP32-S31, but untested on hardware.

Open source (Apache-2.0): https://github.com/leopardcodeai/chakra-detection

Happy to hear from anyone who plays bowls: does your set match C to B, or would you learn it?

Built on Espressif's esp-mosaico-vibe workspace and ESP-GSP simulator; test recordings from Wikimedia Commons (free licences), not shipped in the repo.

Hi everyone!

I’m an AI Engineer with hands-on experience building and deploying AI products, and I’m currently looking for remote AI Engineer / Machine Learning Engineer opportunities.

My experience includes:
1. Computer Vision: Object detection, ball and player tracking, pose estimation, and real-time sports video analytics.
2. Generative AI: LLMs, RAG, embeddings, vector search, and multimodal AI applications.
3. Machine Learning: Model training, evaluation, predictive modelling, and optimisation algorithms.
4.Production AI: Python, PyTorch, TensorFlow, Docker, CI/CD, GPU inference optimisation, and API integration.
5.AI Product Development: Building end-to-end solutions, from data collection and model development to deployment and real-world use.
I’ve worked on AI products in sports analytics, fashion technology, and AdTech.

I’m passionate about solving real-world problems with AI and would love to join a team where I can contribute, learn, and grow as an engineer.

I’m open to remote full-time roles, contract work, and freelance projects.

Spread-spectrum mark: chroma + luma tiles, pilot tiles, Viterbi + CRC. 0 wrong values, 0 false alarms in our 480-copy benchmark; failures (fog, night, B&W + crop) are in the README.

https://github.com/thevijayparmar/Ghostmark-Image

Can someone tell me in detail the difference between CNNs and the software from the sensors from Keyence, Cognex, Zebra. I can't imagine that it's really "AI" what they are using with like no computing power in their tiny edge devices. Can someone explain it to me? Are there approaches to use open source for industry? Thanks!

I cleaned up what we ship for the open eval demo (fruit conveyor inspection — grading only in centre cell C, not full-frame chase).

What changed:

- Release build tuned for size (opt=size, x86-64-v3) -Fruit_Inspector.exe is about 3.8 MB now (was ~5.8 MB on the old drop).

- Public archive Fruit_Inspector_DLL.7z is ~14 MB unpacked tree - CPU ONNX Runtime only in lib/cpu/ (plus bundled MSVC CRT there, no separate VC++ installer for the operator).

- Not in the default demo zip: lib/cuda/, lib/openvino/ - bring your own if you switch EP; default settings.json stays cpu.

- Still in the zip: Fruit_Inspector.exe, trig.exe(TCP client for GOOD / BAD+apple id), three inference DLLs, apple models, licenses.

Unchanged product logic:

- 3×3 grid, stable IDs, Cat/LightGBM only when focus is in C.

- Nim shell+ORT in DLLs -same architecture as before, just less junk around it

Download (eval,non-commercial):

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

Release 0.10.0 - Fruit_Inspector_DLL.7z.

Linux zip on the same release is unchanged from the earlier port.

If you unpack and run on Win64 CPU - curious if anything breaks vs the old fat bundle.

Best regards

olesha-ai

Hey all, I work on LightlyStudio, an open-source tool for looking through and curating CV datasets.

Embedding plots always bugged me a bit. You get nice clusters, but the x and y axes don’t actually mean anything. So we added text axes: you type a word or phrase for each end of the two axes and the points get placed by how well they match. Put “night” and “day” on x and “indoors” and “outdoors” on y, and you get four quadrants you can actually read. Then you can lasso a corner and see what’s in there.

By default it uses MobileCLIP for images and Perception Encoder for video, but it works well with other multimodal embeddings like Gemma too. You can bring your own.

• Repo: https://github.com/lightly-ai/lightly-studio
• Docs: https://docs.lightly.ai/studio/workflows/embeddings/#text-axes

It’s Apache 2.0. It’s still pretty fresh, so any feedback is really appreciated, good or bad.

I built a face shape detector and decided early that nothing would leave the phone. 468 point mapping, all local, no account.

Few things that surprised me. Lighting and camera angle shift the result more than the model itself does, so most of my work went into handling that rather than accuracy. Also most faces sit between two shapes, a single clean label like "oval" is usually wrong, people respond better to a blended answer.

If anyone else is doing on-device vision work, curious how you handle the angle problem.

\[https://play.google.com/store/apps/details?id=com.ai.face.shape.detector.meface\\\]

Hi!

Some time ago I showcased here Rendersynth, a Blender extension to generate synthetic computer vision datasets without writing Blender Python scripts.

I received some useful feedback so I thought I'd share a small update on the project:

• Synthetic thermography: I've been working on IR-synth, a separate Blender add-on for generating synthetic thermal imagery from temperature fields and radiance models.
• Pixel semantic segmentation: Replaced the previous approach with pixel-level segmentation masks with cryptomatte.
• Quality of life improvements for the other formats (normal maps, depth maps, point clouds, keypoints, bounding boxes, ...)

Source code for both modules is available at:

For the main body: https://github.com/lorenzozanizz/rendersynth
For thermography: https://github.com/lorenzozanizz/ir-synth

The goal is still to make synthetic dataset generation accessible for smaller CV projects, without having to build and maintain custom Blender Python pipelines.

I plan to integrate the two projects into a single suite and write hooks for external frameworks like Blenderproc. If you feel like trying it (Blender 4.5.0+) expect to find some nasty bugs, since its still a prototype.

Any suggestions or criticism are welcome! Especially if you have any feedback or advice on the synthetic thermography component it would be greatly appreciated!

Thank you for you attention!

As a side note, for the demonstration I used free models from SketchFab, 3DAI, CGTrader

We're collecting difficult document pages for regression tests, especially cases where the output looks plausible but a number, row or label is wrong.

One of ours is this receipt. It has six product and packaging rows, plus discounts below three of them. An LLM returned nine item records by treating the discounts as extra products. Our schema had no separate discount field and asked for every line item/product, so the instructions left that interpretation open.

Source: NAVER CLOVA's CORD-v2 dataset, CC BY 4.0, image unchanged.

What image or document do you keep around because OCR or layout extraction repeatedly gets it wrong? Handwritten corrections, faint punctuation and wrapped table rows are a few examples we'd like to test.

Public links or redacted snippets would be useful. Include the line, row or field you wanted, what the output should be, and what went wrong. The reader/model and preprocessing settings help too, if you have them. It doesn't need to be a whole dataset.

Hi everyone,

I'm prototyping a tool for an urban planning consultancy in Germany.

Currently, their analysts spend 2–3 days walking streets on foot to manually spot:

1. Vacant infill lots ("Baulücken"): empty gaps or underutilized surface plots between perimeter buildings.

2. Vertical extension potential ("Aufstockung"): buildings with flat roofs or lower height than neighboring buildings that could take 1–2 additional floors.

We are testing this in Lower Saxony (Hannover). From initial research, I found that our state survey office (LGLN) provides official 3D building models (LoD2) and 20 cm aerial orthophotos (DOP20) completely free as Open Data.

Before building from scratch:

- Are there existing open-source tools, repos, or workflows that leverage LoD2 3D models / aerial rasters to automate infill & rooftop potential?

- Is it better to solve this purely via 3D vector/GIS math (building heights delta, roof shape analysis in QGIS/Python) or combine it with Computer Vision on street-level imagery (Street View / Mapillary)?

Appreciate any pointers, papers, or libraries!

Hello

A month ago I posted v1.0 here (12k images, one 7–12 letter word each). A commenter pointed out that real queries are much shorter, and the production numbers agreed: the median query has 5 distinct characters and a quarter have 3 or fewer. So v2.0 matches that.

WhatFontIs-Bench v2.0:

- 60,000 images, 3,000 fonts (1,059 sans, 1,000 serif, 500 slab, 300 script, 141 mono), same three types and difficulty levels as v1

- the text length, case and digit/& mix are sampled from production query statistics; the strings themselves are COCO-Text v2 strings, not user queries

- labels: font, text, word quad, per-letter quads, camera transform; JSONL + COCO, CC BY 4.0

- a 1,200-image subset that scores within about a point of the full set, for quick checks

Baseline (our own API, open catalogue of 1.2M fonts, top-k by font family), top-1 by number of different letters, pro mode / default mode:

- 1 letter: 48.2% / 43.2%

- 2 letters: 73.8% / 64.7%

- 3 letters: 86.2% / 77.3%

- 4 letters: 89.6% / 82.6%

- 5–6 letters: 92.0% / 86.8%

- 7+ letters: 93.5% / 89.8%

- all 60,000: 88.1% / 82.2%

Above five letters it is as easy as v1; below three, there often isn't enough of the font in the image to separate it from its near-twins. The controlled-glyph diagnostic set (same font and background, only the word varies) is the next one.

Hugging Face (viewer, config v2): https://huggingface.co/datasets/whatfontis/WhatFontIs-Bench

GitHub: https://github.com/whatfontis/WhatFontIs-Bench

Disclosure: I run WhatFontIs, and the baseline is our own system. If you run a model on it, I'd like to see the numbers.

I'm looking for software that can organize hundreds of graduation/event photos into folders for each person.

Some photos contain diplomas with names, which could be used to identify and group the surrounding photos.

Before building my own solution, I'd rather use or adapt something that already exists.

Does anyone know an app, GitHub project, or AI tool that does this or something similar?

Open source, paid, cloud-based — all suggestions welcome!

If anyone has opportunities feel free to reach out