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

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.

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

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

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\\\]

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.

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!

If anyone has opportunities feel free to reach out

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!

Hello,

Durint the last reviewing round, 2 reviewers suggested adding qualitative results. The task is pose estimation.

How do I chose the examples to include? And to which baseline should I compare to since space is very limited? Should I include a failire case?

Thanks

Background

I'm coming up with ideas for my CS degree capstone project. I like making short films, so I looked into what kind of software I could make to facilitate the process. One thing I find annoying in post-production is having to go through all the recordings and look for the clapperboards on each video to know what scene, shot and take the video is of. My idea is to train a neural network to find the clapperboard in each recording and extract the information written on the clapperboard to appropriately name the recording. Ex. Avengers_Scene_4_Shot_5_Take_3.mp4.

In short, the neural network would do the following:

1. Detect the clapperboard in a video frame.
2. Read the handwritten text/numbers on the clapperboard.
3. Understand what each piece of text represents

My questions

1. I have not been able to find a lot of videos with clapperboards I could use to train my model. I'm thinking I could create my own videos to train it, so it is trained faster with a consistent clapperboard format. How many would I need more or less to have it not only recognise handwriting but also determine what the numbers indicate (Scene, shot or take)?
2. If it would be too hard to train the AI to do what was previously mention, could I get an already trained AI in handwriting recognition and specialise it in clapperboard data extraction? Would this make my final year project too easy?

Hi everyone.

I've always had lots of photos on my laptop, and it's very difficult to look through them. Google Photos works, but I prefer to have everything locally, and it's also not possible to change directories based on what I want to look at.

So I decided to create an app to do so.

Found it super useful, so I decided to open source it too: https://github.com/chaseleantj/orchard-photos

It runs fully locally using SigLIP 2. It takes about 8s to index 1k photos on an M5 Pro GPU, and 1 min on CPU only, and 5 min/1k photos on a regular Windows office laptop.

There's text search, where you just describe what's in the image, and image search, where you drag and drop to find similar images. There's also some small QOL features like stacking near-duplicate images together. You can open whatever folder you want, or the root, in which case it scans all folders on the device.

For the map, I applied UMAP to project the embeddings into 2 dimensions, so images that are closer together look more similar to each other.

Hope you guys find it interesting.

a custom multi-language OCR pipeline on a single GPU was choking as load grew (~4 detections/sec, 3s+ tail latency). The plan was a second GPU. Instead we optimized serving on the same card and got 55–125/s with ~100ms tail latency, and memory use actually dropped.

I can’t share the specifics since it’s internal work, but I’m curious how common this is. Have you seen teams scale hardware when the real issue was utilization? What was the bottleneck in your case?

Those percentages are exact matches against 578 hand-checked amounts, dates and ID numbers per condition. Every digit has to be right. Invented numbers are outputs that weren't on the page, totalled across the three conditions. Timings are on an M4 Max.

I ran this because I'm building Fyllyo, a Mac app that fills PDF forms from supporting documents. A missed number can be left for review. A plausible number that wasn't on the page is much easier to overlook.

The test was 17 pages: statements, 1099s, a W-2c, a tax transcript, a prior return and letters. Eight were real statement pages and nine were made for test clients. Each page was tested as a clean image, a simulated scan with tilt, blur, grain and JPEG compression, and a simulated phone photo with perspective, uneven light and blur.

The result that surprised me was Gemma's 73 invented numbers. The outputs looked like plausible amounts. LightOnOCR-2 read every known number correctly in this test and invented none. I ran the 1B model at Q8 with llama.cpp; it is about 1.1 GB.

GLM-OCR also invented none, but sometimes skipped whole blocks. Apple's readers were much faster. Reading in strips improved Vision's exact-match rate, but it also produced 25 invented numbers, compared with 3 for the whole-page pass. A higher match rate by itself didn't tell the whole story.

I also compared five readers in every pair across the three conditions: 30 pair/condition comparisons. No pair agreed on an invented amount in this test. That gave me a reason to use a second reader and flag disagreements, but it doesn't prove two readers can't make the same mistake.

Fyllyo now uses the PDF text layer where it holds the numbers, LightOnOCR-2 for page images, and Apple text recognition as a second reader. Disagreements are shown for review.

The limits matter: 17 pages, one Mac, simulated scans/photos and a narrow exact-number task. This isn't a general OCR leaderboard, and 100% here isn't a guarantee on another document set.

Full setup and results: https://fyllyo.com/blog/ocr-models-tested-on-tax-documents

Disclosure: I build Fyllyo. This post was drafted with AI assistance; the experiment and results are mine.

I'm building a Quest 3 app (native Kotlin, Meta Spatial SDK) that scans microgreens trays and needs a pixel mask of the plants to measure coverage (plant pixels / tray pixels). I already have Muse Spark working via Meta's Model API for the verdict text, but I can't find a SAM endpoint in the same API — SAM 3/3.1 segmentation, not a chat model.

1.

Does Meta's Model API expose SAM at all? If so, what's the model ID, endpoint, and mask format?

2.

If not, what's the recommended path from a Quest app — a hosted SAM API (Roboflow, Segmind, etc.)? What mask format do those return (mask image, RLE, polygons)?

3.

On-device SAM on Quest is off the table (too heavy) — is a backend service the only other option?

The mask feeds a coverage calculation, so I need actual pixel data, not a text estimate. Thanks!

"I think this mainly happens due to pose model confusion, which directly affects the 3D reconstruction in certain frames. I considered frame-to-frame averaging, but it's ineffective during fast motions."

I rewrote an old Raspberry Pi project of mine that never worked. Now it:

• recognises enrolled faces (YuNet detection + SFace embeddings, cosine match)
• detects the 80 COCO object classes with YOLOX-S via cv2.dnn
• speaks what it sees, with rules so it doesn't nag: greet a person once per 30 s, debounce unknown faces, confirm an object over two passes before naming it
• runs object detection on a background thread so the video and greetings stay smooth

Only dependencies are opencv-python, numpy and pyttsx3. The models download from the OpenCV zoo on first run.

Code: https://github.com/heditrigui/scouter-2

I'd love ideas on making it lighter for a Pi 3 (YOLOX-S at 640 is heavy).

Here’s the next tutorial in my event camera series. It explores different ways to represent raw event data so that algorithms can use it.

Try the interactive examples in the full blog: https://www.pattarsuraj.com/blog/event-camera-representations

#computer-vision #neuromorphic #event-camera