beartype VS nerfstudio

https://github.com/beartype/beartype

I wish more people started using Beartype, it makes Python bearable

I saw this on /r/Python the other day...

As other folks have commented, type hints are now a big deal. For static typing the best checker is pyright. For runtime checking there is typeguard and beartype. These can be integrated with array libraries through jaxtyping. (Which also works for PyTorch/numpy/etc., despite the name.)

Maybe you're looking for https://github.com/beartype/beartype for runtime type enforcement; it's only at function calls, though, but probably a decent solution for codebases that are not completely typed for MyPy or pyright.

It is though, if you add a type checker to your pipeline and use it without any escape hatches such as `Any` or `type: ignore`, you are essentially making the promise that your code is statically typed. But I say it is a matter of perspective because in my opinion runtime type checking should be avoided if we can get away with statically typed code, but there are type checkers that perform runtime type checking via annotations such as [Beartype](https://github.com/beartype/beartype) (with some trickery like assuming homogenous data structures as to not have to check every element of every structure). Anyway the definition of "type safe" is not 100% even in compiled languages.

There is the beartype project.

Personally I find working around mypy's quirks to be more effort than it's worth, so to offer another option: typeguard or beartype can be used to perform run-time type checking.

You’re under the right paper for doing this. Instead of one big model, they have several smaller ones for regions in the scene. This way rendering is fast for large scenes.

This is similar to Block-NeRF [0], in their project page they show some videos of what you’re asking.

As for an easy way of doing this, nothing out-of-the-box. You can keep an eye on nerfstudio [1], and if you feel brave you could implement this paper and make a PR!

[0] https://waymo.com/intl/es/research/block-nerf/

[1] https://github.com/nerfstudio-project/nerfstudio

Try rendering NERFs with your footage, you're gonna love the result and NERFs are pretty robust to reflections. You can use your Metashape solve for Nerf Studio https://github.com/nerfstudio-project/nerfstudio

Beyond these tips, I don't have much. There's lots of research about how to improve quality of solves in the software itself. I'm hoping these get added to instant-ngp, since it's fast and free, but it is research software, not a product, so we'll see. Another thing to maybe look at is Nerfstudio. It can use instant-ngp as a solver, but there are other solvers. I briefly tried it but couldn't figure out how it worked, from the small bit of time I spent with it. I hope to get back to it.

nerf.studio | github | discord