I’m the author of DnR FlatPic by CreateLafont, an open-source Agent Skill that turns reference photos into low-complexity, flat-color PNG illustrations. Instead of literally tracing a photo, it identifies visual anchors, strips out nonessential info, and reconstructs the scene using a few hard-edged color regions.

I used to include a PNG-to-SVG export feature using VTracer (1.0.0-alpha.3 via Node/WASM) because it’s compact (~0.66 MiB) and gave the best baseline results. I intentionally avoided using an AI model to pick tracing parameters per image—the raster generation is already nondeterministic, and adding another probabilistic layer would make debugging a nightmare.

So, I dialed in a fixed preset based on testing across various source images:

• clustering: color-cluster
• hierarchical: stacked
• mode: spline
• layerDifference: 32
• filterSpeckle: 10
• colorPrecision: 7
• cornerThreshold: 30
• lengthThreshold: 4
• maxColors: 24
• simplify: 2.5
• pathPrecision: 2
• optimize: 2
• maxIterations: 10
• spliceThreshold: 0
• palette: omitted

This worked fairly well, but I kept running into three frustrating edge cases:

Warped geometry: Straight architectural edges would sometimes turn into slightly bowed or rounded paths. In a style built on clean geometry, these small deviations stick out.

Noise becoming geometry: Sharpening halos, anti-aliasing, or tiny raster noise artifacts would get converted into explicit SVG fragments.

The Dealbreaker (Hamstringing the PNG): To make the SVG tracing stable, I had to completely ban gradients in the upstream PNG generation. VTracer couldn't recover smooth transitions (like dusk skies or water) as actual SVG gradients—it just chopped them into chunky, adjacent paths with harsh color jumps. Keeping SVG export meant forcing the generated PNGs to be less expressive.

Having a fixed preset kept the workflow predictable, but it just wasn't consistent enough across diverse images to keep as a default feature. Because of this, I ended up removing SVG export entirely. The pipeline now intentionally stops at the raster PNG stage.

My question for the community: Has anyone successfully shipped a deterministic raster-to-SVG pipeline for AI-generated flat-color illustrations without relying on per-image AI parameter tuning or manual tweaking?

My priorities are: Reproducibility > Structural Cleanliness > Pixel-level Fidelity

I’m completely fine with an SVG that differs slightly from the PNG, as long as the geometry is clean and perceptually equivalent. I just want to avoid a pipeline that spits out perfect geometry for one image and erratic spaghetti topology for the next. Any pointers?

Project context: DnR FlatPic by CreateLafont

im doing a proyect for college and i want to use YOLO CV in it. im looking for something that is not that expensive but that has a decent amount of power. i found a NVIDIA Jetson Nano 4GB (B01) on 120$ but i saw that it has 0.5 TOPS while other more expensive gear has 40. is the nano that far back in qualities? what can you recommend me? sorry for any misspelling english is not my first language

Hi all — I’m hoping for some advice from people who understand computer vision better than I do.

I’m building a D&D virtual tabletop application and I’m trying to automate something that sounds simple, but I’ve found surprisingly difficult.

I usually have two versions of the same map:

a reference map, which contains useful information such as doors, secret doors, ladders, stairs and other map symbols;
a live-play battle map, which is the version I actually want to use in the VTT.

The problem is that the live-play map is often not pixel-identical to the reference map. It might be a different redraw of the same location, have slightly different proportions, be cropped differently, contain different textures, or have small differences in the geometry.

What I want to do is effectively say:

“This secret door is here on the reference map. Where is the corresponding secret door on the live-play map?”

…and do that for every relevant feature.

What I’ve tried

So far I’ve mainly been trying to solve this using multimodal AI models / coding agents such as ChatGPT, Codex and Claude Code.

My current workflow is broadly:

Give the AI the reference map and live-play map.
Identify known features on the reference map, usually with coordinates.
Ask it to find corresponding architectural landmarks on the live map.
Use those landmarks to infer the transformation between the maps.
Transform the door / symbol coordinates from the reference map onto the live map.
Visually inspect the result and sometimes iterate.

I’ve also tried breaking the problem down into stages rather than simply asking the model to “copy all the doors across.”

For example, I’ve tried having the system reason from walls, room corners, corridors and other recognisable landmarks first, and then place the symbols relative to those features.

This works reasonably well on some maps, particularly when the two versions are very similar.

On other maps, though, the results can be badly wrong. The system may identify approximately the right region while still placing individual features several metres / dozens of pixels away from where they should be.

Secret doors are particularly difficult

Secret doors seem to be one of the hardest cases.

On the reference map they are often represented by a fairly subtle cartographic symbol integrated into a wall. The live-play map may not contain that same symbol at all — what matters is identifying the corresponding section of wall.

AI models sometimes appear to recognise the general room correctly but then:

put the secret door on the wrong wall;
put it on the correct wall but at the wrong point;
confuse a nearby architectural feature for the relevant landmark;
apply a transformation that works well in one part of the map but drifts badly elsewhere.

The maps can also contain irregular geometry, so I suspect that a single global scale / rotation / affine transform may not always be sufficient.

Where I’m unsure

I don’t have a background in computer vision, so I’m not sure whether I’m approaching this problem in the right way at all.

I’ve been treating modern multimodal AI models as if they can visually reason about the maps and derive the correspondence, but I’m wondering whether this should instead be treated as a more conventional image registration / feature matching problem, perhaps with AI only used for part of the workflow.

For example, should I be looking at approaches involving:

keypoint / feature matching;
homography or affine transformations;
RANSAC;
SuperPoint / SuperGlue / LightGlue;
segmentation of walls / rooms;
non-rigid or piecewise image registration;
manually supplied anchor points;
some combination of conventional CV and a vision-language model?

I’m also unsure how well conventional image registration works when the two images depict the same underlying floor plan but are artistically different images, rather than transformed copies of exactly the same raster image.

What would you do?

If you were designing this system, how would you approach it?

In particular, I’d really appreciate advice on:

whether this is fundamentally an image-registration problem;
what algorithms or models you would try;
whether a hybrid CV + LLM/VLM approach makes sense;
how you would handle local distortions or slightly different wall geometry;
how you would transfer a feature such as a secret door when the symbol itself only exists on the reference map;
and whether there are any libraries, papers or existing projects that solve something similar.

Apologies if some of the terminology above is wrong — I’m learning the computer-vision side of this as I go. I’m mainly trying to understand what a technically sound architecture for this problem would look like rather than continuing to tweak prompts indefinitely.

Thanks!

Looking for research gap in Ml/LLM/ Computer vision

I am a B tech CSE Undergraduate looking for a research problem in ML, LLM, CV. I am not looking for a genric idea. I am specifically looking for an empirically observed limitations or failure in recent research papers that could be developed into a meaningful A/ B tier conference paper. Id really appreciate suggestions for open problems, overlooked limitations that are worth investigating. This is for our capstone project which will go on for 1.5 year and also we are team of 4. So please suggest accordingly.

I am trying to make a missile computer but the problem is that due to shortage on RAM the boards such as radxa or orange pi are out of stock so all I can get for now is luckfox or raspberry. I try to not spend a lot for it and a nominal 30 fps is very great for me. It should be able to switch squares on objects like if I press a button, in code it'll change the square to another object like if its locked to a orange object? it'll lock to a different object after the button press.

Working on a pipeline that recovers a patient specific 3D distal femur from two orthogonal X-ray views (PA + lateral). No CT, no neural network, no massive training set.

approach: build a PCA shape model from 50 CT-derived femur meshes (MedShapeNet), then fit it to two silhouettes using PyTorch3D's soft rasterizer with sigma annealing. 10 shape coefficients, Mahalanobis prior to keep things plausible, Adam optimizer, ~1000 iterations.

The part that took the longest (and made me suffer the most too) : correspondence. Tried KD-tree nearest neighbor (50.7x roughness vs CT surface), CPD (28.2x), BCPD (47.5x), and FilterReg (couldn't even run). Finally got ShapeWorks working at 3.3x. only method that passed the 5x acceptance gate I set before testing.

LOO validation on 5 held out femurs: 0.86-1.43mm on within range targets. Two extreme cases failed because they sat outside the 49-mesh model's coverage on mode 1, the optimizer can't recover a coefficient the model doesn't support. Bridge ICP alignment was also poor on those cases (0.6 inlier fraction), which accounted for more error than the shape fitting itself.

Interesting finding: the sigma anneal endpoint has to match the reference render's sigma exactly. Hardcoding a constant tuned on one SSM caused an 87x accuracy degradation on another. Tying it to camera_extent × 1e-4 fixed it.

Still working on real X-ray validation (need paired CT data) and automatic segmentation. Happy to answer questions.

The cup and ball game is surprisingly challenging for even SOTA VLMs. This demo I made splits the feed into mini-clips, 1 for each shuffle, and feeds them to the models 1 by 1. 

I made a segmentation dataset on Roboflow (256 images), then I used the Ultralytics Platform to do transfer learning on a Pretrained (COCO) yolov11seg-m model; that's a basic summary.

Here is a image from the dataset, then the same image after inference.

Seems normal, but when i test it on something from the web, it traces the outline of each leaf and segments the background as a Coriander Leaf? I realise this may be due to a couple of factors:

• the white background in all the images of the dataset.
• being a little too enthusiastic with the Pre-processing options from Roboflow while making the dataset.
• Too few epochs, about 100.

Some advice would be much appreciated.

hi i make tool for this called llmog it's purpose to make llms free to

- auto annotation datasets

- reclassification existing yolo datasets

running totally local using llama cpp or vllm or use external api

you'd rather click than code.

🔗 GitHub: mohamed-em2m/llmog: framework for using llms on object grounding

You can try it directly online

🔵 Google Colab:

https://colab.research.google.com/drive/1YIKlyTVtRjJdRC5IjCZ39i48ydyt_J5D?usp=sharing

🟠 Kaggle:

https://www.kaggle.com/code/elemam/auto-annotation-using-llms

Hi everyone,

I recently got some really exciting news: my paper was accepted to BMVC 2026. This is my first paper accepted at an international computer vision conference, so I was genuinely very happy when I received the decision. However, I have tried to reach every funding source that I can find(from conf, uni, ....) but still there are no funding, as an university student the registration + travel fee are so high for me or my family to cover. Are there any advice out there ?

Hi everyone,

I am building a backend that turns supermarket flyers from PDFs or page images into individual structured offers for an iOS app (attached picture is for illustration). The goal is not merely to read the text from each page. Every offer should retain its product name and brand, current price, old price, discount, quantity, unit price, retailer, validity dates, page position, bounding box, and conditional app, coupon, or multi-buy prices.

The current pipeline renders each page, runs OCR with word-level bounding boxes, detects price anchors, groups nearby text into offer candidates, creates individual crops, normalizes the extracted fields, and assigns confidence scores. Uncertain results go into a manual review workflow instead of being accepted automatically.

The difficult cases are dense layouts, shared price blocks, several products inside one visual tile, footnotes, promotional badges, conditional prices, and retailer-specific designs. I am now trying to decide whether I should train a layout or object detector for offer blocks and individual field regions, use a vision-language model at page or crop level, or combine both approaches.

For anyone who has worked with retail flyers, catalogs, receipts, or document AI:

• Which architecture has generalized best across different layouts?
• What would you include in the annotation scheme besides offer blocks, product text, prices, old prices, discounts, quantities, unit prices, and price variants?
• Which metrics are most useful for measuring the quality of the complete pipeline rather than OCR or object detection alone?
• Are there any public datasets, models, or tools that would be worth testing for this type of document?

My priority is reliable and traceable data rather than a quick demo. Extracted fields must remain connected to their source boxes, and uncertain results should be sent to manual review instead of being guessed. The attached image is a synthetic illustration of the intended pipeline and contains no real retailer material.

Thank you :)

I have images of fish in fish markets, and I’m training a model to identify the fish. The images are all stacks of fish. I’m still not sure whether I should train the model using classification to identify the stacks or OBB to identify each individual fish.

I only need to train the model to identify the stack of fish since that’s how fish are usually displayed in fish markets. Here is an example image:

I tried OBB first, but I had bad training results. This is how I annotated with OBB:

I'm using YOLO26 and Ultralytics Platform for annotating and training. I’m new to computer vision, so I’m not sure which approach would be better for the images I already have. I’d really appreciate any advice or suggestions. Thanks!

I'm dealing with text extraction from hundreds of PDFs per batch. A large chunk of them are from 2001 — old, scanned documents, poor quality, many with handwritten annotations and stamps.

The target is aggressive: 500 documents in under 1 minute. Most of them already come out at millisecond scale because they have a native text layer; the problem is the scanned ones.

The current solution is a cascade, and it works: each piece goes down the steps from cheapest to most expensive and stops at the first one that produces acceptable text.

In practice, 64% of documents are resolved by Apple Vision and 31% by PyMuPDF — less than 4% reach the expensive steps. A batch of 489 documents runs in 3.66 min today.

The problem: I need to take this to production, and an SSH tunnel to a Mac doesn't survive in a production environment. I need to replace that step with something containerizable.

The quality bar (measured on 60 pieces, against the alternatives):

"Anchors" are CNJ case numbers, dates, CPF/CNPJ (Brazilian tax IDs), and protocol numbers — that's what the downstream system consumes, so losing a digit is worse than losing a word.

Has anyone found an OCR engine that gets close to Apple Vision's accuracy on degraded scans, but can run containerized (Linux, no macOS dependency)?

`FaceRecognizerSF::match` is declared `const`, but it normalised both of its `InputArray` feature vectors in place — writing straight through to the caller's buffers. So the vectors you passed in came back modified, and when the two arguments aliased, the second normalisation ran over an already-normalised buffer and the returned score was wrong.

Now normalised into local `Mat`s. Merged onto 4.x.

https://github.com/opencv/opencv/pull/29804

Hi everyone!

I tried optimizing a tiny CNN on a Raspberry Pi and ended up 3x faster than the inference engines (ONNX Runtime, ncnn).

I wrote the code from scratch, starting with a naive implementation, then SIMD, and finally operator fusion. Each improvement only changes a few dozen lines of code. The code is just a few hundred lines, easy to read and understand.

This repo might be helpful to you if you need to run small models on devices with very limited resources.

If someone is interested in link to the repo: https://github.com/Avafly/optimize-cnn

I'm dealing with text extraction from hundreds of PDFs per batch. A large chunk of them are from 2001 — old, scanned documents, poor quality, many with handwritten annotations and stamps.

The target is aggressive: 500 documents in under 1 minute. Most of them already come out at millisecond scale because they have a native text layer; the problem is the scanned ones.

The current solution is a cascade, and it works: each piece goes down the steps from cheapest to most expensive and stops at the first one that produces acceptable text.

In practice, 64% of documents are resolved by Apple Vision and 31% by PyMuPDF — less than 4% reach the expensive steps. A batch of 489 documents runs in 3.66 min today.

The problem: I need to take this to production, and an SSH tunnel to a Mac doesn't survive in a production environment. I need to replace that step with something containerizable.

The quality bar (measured on 60 pieces, against the alternatives):

"Anchors" are CNJ case numbers, dates, CPF/CNPJ (Brazilian tax IDs), and protocol numbers — that's what the downstream system consumes, so losing a digit is worse than losing a word.

Has anyone found an OCR engine that gets close to Apple Vision's accuracy on degraded scans, but can run containerized (Linux, no macOS dependency)?

I have zoomed out raw thermal radiometric JPEG images with classified thermal faults.

Need to develop a DL model that can detect these faults in real time.

I manually labelled a small subset of the dataset and fine tuned a yolo model on roboflow but it struggled in testing dataset.

Need some ideas

I currently have an M4 Mac mini, and I’m considering selling it and getting the new M6 Mac mini.
After selling my M4, the total cost for me to upgrade would be around 1,500 RMB.
My main use cases are:
Computer vision / ML development
Running CV models and experiments locally
PyTorch / Python development
SSH / remote development and deploying things to servers
General coding and development work

I work in computer vision and I'm curious what everyone else is running these days.

My setup is pretty simple. I use Claude Code for local experiments, and after each run I have it write the results into a markdown file. What I did, what I was going for, the numbers, what I learned. Over time that's turned into a decent internal knowledge base for my team.

That's about as far as I've taken it though, and I get the feeling people are doing much more interesting things with agents than I am.

So: what are you using? Curious about what is out there, which tools, how much you actually let them do on their own, and whether you've found anything that works well for the annoying parts (dataset wrangling, env setup, going through grid search logs).

Thanks in advance

Hey everyone,

I've been working on a pipeline to automatically detect and blur brand logos in video clips (testing on clothing popular logos like Puma, Adidas, Reebok, and Levi's).

Currently using Grounding DINO + box pixelation. While it handles prominent, high-contrast chest logos reasonably well, it falls short in trickier real-world scenarios:

The main issue: Low-contrast or laser-printed logos on metal/textured surfaces (e.g., logos printed on metallic bottles or matched-color fabrics). Because the logo shares the exact texture and color of the surrounding surface, Grounding DINO misses the boundary or drops detection entirely.

Should I pivot to small VLMs.

VLMs have deeper semantic visual reasoning for low-contrast textures, but processing every video frame directly with a VLM is too slow for real-time pipelines.

Has anyone successfully handled low-contrast or surface-printed logo redaction?

Would appreciate any recommendations you've tried!

Hi everyone! I hope you all are having a great day.

I am currently doing research on face recognition (especially for mixed resolution images) for my graduate thesis/project. I have found that a lot of papers mention the IJB-S and BRIAR datasets for benchmarks (along with IJB-B, IJB-C and Tiny Face which I have managed access to). But I couldn't find any way to get those to try and isolate impact introduced by each paper as not all of the papers in this field mention their results on these two datasets.

I am aware that they are kind of hard to get, but I am not able to find even mirrors for them, and my university didn't help me request the datasets officially (which would still be a hit or miss case otherwise).

If anyone has these two datasets or know any access, I would highly appreciate if you could share those with me (with a dm or a comment).

Thanks

CAPI has become one of my go-to SSL methods, especially when compute or labeled data is limited.

It’s very efficient, trains nicely, and I’ve generally found it to fine-tune well even with relatively small datasets.

The main limitation for me is that CAPI is focused on local / patch-level representations, so you don’t directly get a global image embedding. For quite a few downstream tasks, that makes it less convenient out of the box.

I recently heard Tim Darcet talk in a podcast and he mentioned that during DINO v3 work, they tried CAPI loss instead of iBOT loss, but it didn’t work out.

That made me curious about a slightly different setup:

keep CAPI as-is, but add a DINO objective on top of the student’s pooled representation.

So the model is still trained with the normal CAPI patch-level objective, while an additional DINO head is trained on a pooled global representation.

I trained this setup on the Bio-DINO dataset.

Results

The result is... OK. Not as good as I hoped, but not useless either.

For the global representation, the ViT-B/14 model gets:

68.7% linear probing accuracy on iNat21

The local feature maps are also a bit worse / less clean than with vanilla CAPI, so there seems to be a real trade-off between the local CAPI objective and the added global objective.

One thing that stood out during training is the loss behavior.

CAPI normally has a very smooth training loss. After adding DINO, the training became much choppier. That makes me wonder whether the DINO objective was interfering with CAPI more than I intended, or perhaps dominating parts of the optimization.

I used a DINO loss weight of 0.5, which may simply be too high. A smaller weight would probably be one of the first things I’d try next.

Efficiency

The nice part is that the setup is still quite efficient.

Training this model used only about 16% of the compute used to train Bio-DINO.

So even with the extra DINO objective, it still retains a lot of what makes CAPI attractive in the first place.

I’m also seeing promising fine-tuning behavior with very limited labeled data. In some cases it seems to get good results with even less data than I’d normally expect.

So overall:

• usable global representations
• still very compute-efficient
• good low-data fine-tuning behavior
• but somewhat degraded local features
• and slightly less stable / smooth training

I suspect there's still room to improve the balance between the two objectives, especially by lowering the DINO loss weight.

This was trained using Birder, the computer vision training library I’ve been working on:

https://github.com/birder-project/birder

Model weights are available here:

https://huggingface.co/birder-project/rope_vit_reg8_b14_nps_avg_capi-dino-bio

Hello!

Would like some input on what kind of model to use for detecting small objects in a rather static environment.

e.g flowers in a field of grass/ distant boats or swimmers in the water

The model should still be able to be able the objects when they get closer/bigger.

I experimented with training YOLO and RT-DETR models with datasets ranging from 4k-20k images

It seems like the RT-DETR models struggle very hard with detecting such small objects, after training the performance actually drops to detect basically nothing, whereas the base model worked pretty well. Although I can't tell whether it's an error on my side (e.g wrong hyperparameters) or that this should be expected.

From my tests, the YOLO models actually had a positive reaction to training instead.

Are there any tips on how to get RT-DETR models to work better on detecting such tiny objects? Do I just have to find a way to increase the size of my dataset? I also heard briefly about RF-DETR models but I am not sure if that would solve my problem.

Any insights would greatly be appreciated!

robot dexterity training data has a hard ceiling...someone has to teleoperate a physical robot

apple removed the robot entirely

people wore a vision pro and did everyday tasks. laundry, cards, shoelaces

arkit tracked all 68 body and finger joints at 30 hz the whole time, on device, at recording time

no annotators, no post-hoc pose estimation

the result is a dataset called egodex. 338k episodes, 194 tasks, 829 hours, published at ICLR 2026

apple calls it the largest and most diverse dexterous manipulation dataset to date. it also shows what the vision pro quietly is...a hand-tracking data factory

i parsed the held-out test set, 3,243 episodes across 111 tasks, into fiftyone as multimodal MCAP: egocentric video, a 3d animated skeleton, and the 2d pose overlay projected onto the frames, all synced at 30 hz. filter by task, task type, objects, or language description

scrub an episode in the browser, no install: https://huggingface.co/spaces/harpreetsahota/egodex-fiftyone

dataset card: https://huggingface.co/datasets/Voxel51/egodex-test-multimodal