r/computervision

I'm using a plugin btw. Think about the power
u/syntheticdata u/unrealengine

Solo dev here. I kept owning things and forgetting where I put them, so I built Store & Forget.

The whole point is zero effort to catalog: you don't type or tag anything. Snap a photo and it auto-fills what the item is (the photo scan uses a cloud AI service). Later you find it by searching names, descriptions, or which box or room it's in, or tap "Smart Find" to search by meaning.

Local-first: everything sits in an on-device database, no account, no sign-up. Optional backup to your own Google Drive.

It's free, Android only. Would love feedback from other builders.

https://play.google.com/store/apps/details?id=dev.koalalab.storeandforget

Hi everyone,

We've been building LocalMesh for the past few weeks, and the beta just opened.

Short version: one photo goes in, and you get a 3D Gaussian splat (~60s on a 5090, ~2min on a 4060 laptop), then a textured mesh** (UV-unwrapped, photo reprojected, AO, normal map) exported as GLB/PLY/OBJ.

Everything runs locally. No upload, no queue, no credits. Turn off your Wi-Fi, it still works.

The mesh part is the bit we're proud of. Poisson reconstruction on gaussian centers drapes a tarp over your object: a Poisson solver has to close every surface, and can never say "I can see through here".

So instead: 60 virtual cameras on a golden-angle sphere, gsplat renders depth for each, every ray carves out the empty space it travels through, and the 60 depth maps fuse into a 768³ TSDF volume. Carving instead of guessing. (gs2mesh principle, written from scratch.)

Other things you might enjoy:

- It runs on 8 GB cards. The entire conversion (splat rendering, TSDF fusion, decimation, atlas bake) stays under 7.3 GB of VRAM, so a 4060 laptop finishes the exact same job as a 5090, just slower.

- No CUDA toolkit, no Visual Studio, no Python, no admin rights on the client. We ship a fat gsplat wheel with precompiled kernels, RTX 20 to 50.

Limits, upfront: one photo means the back of the object is invented, not measured. Windows + NVIDIA 8 GB only. No Authenticode cert yet, so SmartScreen will grumble on first launch.

7 days free, no card to start, then $39 once, no subscription, because there's no cloud to pay for: https://local-mesh.com

Break it and tell us, that's what the beta is for.

Happy to answer anything about the pipeline in the comments.

I do Computer Vision as part of my job and just felt like it would be fun to spin up something to play this game.

Its not perfect, due to sometimes words being overlayed on each other which results in bad detection. But it does get the job done.

Any fellow Computer Vision Engineers playing Dota 2 as well?

I know you can just create a script like This post, where it just spams all the letters on the keyboard continuously. But I just thought this would be more fun, and treat it as a challenge to myself to develop the highest scoring solution based on computer vision techniques.

If people are interested in the code I will release it in the comments :)

The black (white) parts of the texture stand out more on a white (black) background. This effect, discovered by psychologist Bart Anderson, is related to the Munker-Benary-White effect, where solid gray regions of identical luminance appear either whitish and blackish. It's a vivid demonstration of the influence of boundary conditions (contrast polarity) on textural figure–ground layer segmentation. Are there any known computer vision algorithms that can segment textures into figure–ground layers in this fashion?

Play chess against frontier VLMs. Real-time vision powered by Overshoot.

Play now: VLM Chess

Hi everyone! I am a software engineer who has worked in the following domains at major tech companies most of my career: XR, Graphics & GPU programming, Spatial algorithms and AI, and 3DGS.

I have a project I started a few months ago that I have recently hit a key milestone in. The idea is a focused library that implements 3DGS training from first principals with an emphasis on performance and safety. Think production use cases without relying on tools intended for research. VkSplat is an inspiration (along with other things) but I have intentionally not reviewed their, or anyone else's, code.

The recent milestone I reached was rendering a scene with 5 million splats at 60fps on my Ampere A6000. I have a few more goals I'd like to reach, but I do intend to publish on Github under MIT license. If it gains traction I would like to build some additional tools and infra using this project, but for right now the 1.0 MVP idea is a fully GPU resident solution for rendering and training at state of the art speeds. I plan to implement and optimize the following features:

• Global image alignment
• Fully fused forward and backward passes
• Adam optimizer
• Aggressively optimized adaptive control and densification
• Stable but highly flexible C api.

I do have many more thoughts and ideas, but I am trying to take it one step at a time, so this is my goal for 1.0. This is my stack as of now:

• Languages: C++23, Cuda, GLSL (planning to move to slang)
• Build: CMake & Ninja
• Compiler: GCC, Clang, MSVC (may drop for now)
• Target Platform: Linux (Linux 7.X)
• Tooling: LLVM, perf, nsight
• GPU: Vulkan w/ Nvidia
• Dependencies: googletest, googlebenchmark, ngfx

Right now, the project is in a place where it is still extremely early, but it is starting to take shape and get large enough that more than one person can work on it comfortably. I am posting here looking for people interested in contributing. Knowledge is not a prerequisite as I am learning a lot myself in this endeavor, but passion is mandatory.

Currently I am mostly needing help in the areas of, CI/CD (build, package & deploy), nsight/gpu optimization, designing and implementing a good api, and figuring out how to test and benchmark appropriately.

If you have skills or experience in any of these areas, or you're just interested in contributing, please reach out!

I’ve just finished a major rebuild of ClearLab, my mobile image processing app for iPhone/iPad.
The new version adds histogram, RGB parade, waveform, line profile, pixel inspector, statistics, Canny/Sobel/Laplacian edge detection, enhancement tools, format conversion and PNG/CSV analysis export.
The idea is basically a small image-processing lab in your pocket rather than another photo-filter app.
It’s mostly native/deterministic processing, not generative AI.
ClearLab 2.0 is now on the App Store. Curious what people here think, especially anyone working with imaging or computer vision.

Since Ultralytics officially supports exporting YOLO26n-Depth to RKNN, I tried running it on RK3576.

With a simple Python video inference test, I’m getting around 3–4 FPS for now. The code and model haven’t been optimized yet, so I think there is still quite a lot of room for improvement.

One thing I noticed is that the RKNN model exported directly by Ultralytics has only one output.

For comparison, the optimized YOLO11 / YOLOv10 models from Rockchip’s rknn_model_zoo use 9 outputs, which seems to be better optimized for the Rockchip NPU and moves some of the decoding/post-processing outside the model.

So 3–4 FPS is just the initial result. I’m going to see if YOLO26n-Depth can be optimized in a similar way.

Has anyone already tried optimizing YOLO26 or YOLO26-Depth for RK3576/RK3588?

I spent a few days getting an SDXL-based provenance-removal pipeline (visible AI labels, C2PA metadata, SynthID-class pixel watermarks) to run properly on an M5 with 16 GB. Not "it launches" — actually correct and predictable. Almost everything I assumed was wrong, and the measurements are the interesting part, so here they are.

1. The four-step distillation LoRA invents texture, and more steps make it worse.

Low-strength img2img runs the tail of a long schedule (strength 0.15 → the last 4 of 27 steps). A LoRA distilled for four timesteps across the whole noise range is off-distribution there, and wherever nothing conditions it — flat dark fabric gives Canny no edges — it fills the gap from its prior. On a night photo that reads as coloured camouflage across black clothing.

Global stage, 1448×1080, strength 0.15, seed 0	Invented texture	PSNR	Wall
Lightning, 4 steps	1.73× source	28.54 dB	41 s
Lightning, 8 steps	1.80×	28.19 dB	29 s
Lightning, 16 steps	1.84×	27.85 dB	62 s
Undistilled base, 16 steps	1.19×	29.25 dB	71 s
Undistilled base, 24 steps	1.20×	29.17 dB	132 s

Asking the distilled model for more steps made it worse, which is what identified the distillation rather than the step count. Dropping the LoRA cost 3× the wall time and bought both fidelity and correctness.

Wrong theories I paid for first: the fp16 VAE (a bare round-trip is clean in fp16 and fp32, tiled or not, 34.6 dB), Metal's fp16 in general (bf16 measured marginally worse), and Canny picking up sensor noise (the Canny map of that region is empty — which was the actual clue).

2. Metal pages instead of failing, so memory has to be measured, not hoped for.

torch.mps.recommended_max_memory() reports 11.84 GiB on a 16 GB machine. Exceed it and nothing raises — the process just starts swapping and a run that should take 23 s takes an hour.

• VAE tiling off, 1.57 MP frame: 18.74 GiB peak, 59 s. On: 10.92 GiB, 23 s. So tiling is load-bearing on small machines — but its boundaries leave a faint texture, so it's now decided per frame from the budget rather than switched on globally.
• Diffusion untiled at 2.5 MP: went into swap and did not finish in twelve minutes. Tiled at 1024 px, 5.07 MP: 10.93 GiB, 88 s, native geometry preserved.

3. Sequential CPU offload works on MPS, and it's what makes 8 GB usable.

The stack is 7.7 GiB of weights; an 8 GB Mac gives you about 5.3 GiB. Streaming the weights module by module:

Same frame, same seed	Peak device memory	Wall
Resident	7.70 GiB	7.1 s
enable_sequential_cpu_offload(device="mps")	0.28 GiB	24.1 s

27× less peak for 3.4× the time. The plan is chosen from the measured budget and printed, because a run three times slower looks broken unless it says why.

4. Two Metal gaps worth knowing if you're porting anything.

• torch.float8_e4m3fn doesn't exist on MPS at all (RuntimeError: Undefined type Float8_e4m3fn). Any pipeline that streams float8 weights — a lot of the VRAM-managed stacks do — cannot load, full stop.
• SAM's processor emits its box/point prompts as float64, which Metal also has no type for, so moving the batch to the device raises instead of degrading. One cast fixes it.

5. The one that cost me the most: fp16 sampling on MPS silently returns zeros.

I added a memory optimisation — encode the fixed prompts once, drop the text encoders, save 1.52 GiB. Two of four face crops then came back as all-zero black rectangles. Deterministically, same seed, nothing raised.

The embeddings were innocent (CPU fp16, MPS fp16 and fp32 encodings of that prompt agree to 0.0009 on tensors with σ=3.06) and the same crop in isolation was fine. Freeing unrelated memory changed the allocation pattern the crops met after the global pass, and that was enough. I withdrew the optimisation and added a guard that drops any empty crop instead of compositing it.

If you're doing fp16 diffusion on Metal: check your output for degeneracy. It will not tell you.

What it doesn't claim. Regeneration is not payload deletion — faces, text and fine detail move, and the numbers above are the measured size of that. No public local decoder exists for SynthID-class marks, so identify reports unknown, never clean; verification is the provider's verifier or nothing. Metal isn't bit-identical to CUDA, so operating points transfer between backends but recorded verdicts don't. And it's for content you generated or own — the visible-mark registry takes AI-generation labels only, deliberately not stock or marketplace marks.

Because "how much did that cost my picture" is the whole question, it ships as a command:

pagedmark measure before.png after.png

PSNR over the frame, PSNR per detected face, and how much mid-band structure appeared where the source was flat and dark. That third metric is the one that caught the camouflage — per-pixel chroma statistics rank the artifact below the source, because the source's own sensor grain has more per-pixel variance than the invented blotches do.

uv tool install "pagedmark[diffusion]"
pagedmark invisible photo.png -o clean.png

Code: https://github.com/doofzoff/pagedMark · PyPI: https://pypi.org/project/pagedmark/

Happy to answer anything about the Metal specifics — that's the part I'd have wanted written down before I started.