There is no encapsulation either at compile time (you need to recompile your code if you touch any code where the private members change) or run time (feel free to modify those so-called private members, though; all you need is their memory location).
Your gripe about runtime encapsulation is idiotic; you would really have to go out of your way to get the memory address of a private variable (you would have to guess its location, which would be compiler-specific due to compiler-generated members like the vtable or alignment padding), or by requiring the class itself return a reference or pointer to the variable. C++ assumes you're competent and isn't going to stop you in pathological cases.
Exceptions leak memory unless you wrap everything in a "smart pointer"
Using RAII is standard, idiomatic C++. You can use smart pointers for dynamic memory or allocate your variables on the stack. That way, (as long as your destructor is correct), you won't leak memory, even in the face of exceptions. Pretty easy, right? As an added bonus, its performant and deterministic. What's not to like? auto_ptr is gone, and for "that decade" it was standard to roll your own smart pointers or use boost. Now you have unique_ptr and shared_ptr as your primary standard library smart pointers.
There's finally garbage collection in the standard library through std::shared_ptr but it's just reference counting, so just forget about, e.g. lock-free multithreaded data structures..
I guess you'd be pretty amazed to hear that there are portable, lock-free data structures written in C++ then! In fact, boost already has a few. Also, if you really want reflection, Qt has support for it (via MOC, though you'll have to jump through some hoops with QObject).
... software follows no laws.
Tell that to my compiler. I'd say if anything software is very structured; you have a limited pool of recognized syntax that can be combined in specific ways. If you're using a library, you have to adhere to its API. Ultimately your code will be running on some processor, which has a limited set of instructions it can perform. Software has no laws? Hardly.
For your own sanity, stay away.
Sounds like it might already be too late for you...
...are on par with Barack Obama, which is to say non-existent.
But at least they're better than Yasser Arafat or Le Duc Tho.
... but still better than say, Henry Kissinger?
To me, there seems to be plenty if information on recorded video, as it contains previous as well as future frames that should contain sufficient information to provide considerable clarification of a present image frame. Anyone have info on anyone doing this?
This is used already in multi-frame superresolution. TFS seems to be talking about compressive sensing, which is a completely different beast. Compressive sensing is based on assuming sparseness to solve an underdetermined system of linear equations. It doesn't always work (as it's not always a valid assumption), but when it does you can get very impressive results. That is to say, if you have some underdetermined system of equations, it'll have infinite possible solutions. This obviously doesn't lend itself well to getting a good answer from it, but by imposing the condition of sparseness, you can arrive at a (very close to correct) solution.
I hate to be picky
I somehow find that doubtful