Peter M. Groen / openbr

Better support for serializing algorithms in memory

Refactor handling of simplified pointer in AlgorithmCore
Remove parameter from serialize, it's literally impossible for it to do
anything useful
Remove spaces after * and & (saving valuable bytes of source code).

Also, more careful memory management of the simplified transform in
AlgorithmCore

Instead of having a parameter to force serialization of loadStores,
introduce a recursive method for simplifiying transform trees. Transforms
which are only useful during load/training can now remove themselves from
the tree via Transform * simplify, returning e.g. their child transform
instead of themselves when possible.

This avoids the issue of LoadStore transforms refusing to serialize
themselves onto an input stream during multi-process enrollment, since
they are just removed from the tree.

For consistency with other supported compilers, enable a warning about
unused parameters at warning level 3 in visual studio.

By default this warning is at level 4, but using level 4 isn't really
feasible since a ton of warnings are generated for Qt header files.

Rather than saving the Transform and distance strings of an algorithm
together, in stored files, save the transform and distance descriptions
separately. Also introduce an enum allowing for the serialization of
algorithms which use gallery comparison transforms, rather than distances
as their comparison function.

Update pre-trained algorithms, this only requires updating the algorithm
files themselves, transforms saved via LoadStore are unaffected.

This gives us robustness to one type of model file compatibility break, if
e.g. the FaceRecognitionRegistration abbreviation is changed, any results
of <FaceRecognitionRegistration> that were previously saved to disk are
not invalidated (although any changes to FaceRecognitionRegistration will
not be reflected until the model is re-trained).

Expand on Object::description to get a workable string that reflects the
current state of the properties of Objects in memory.

With this, we can conceive of serializing Transforms/Distances without
having prior knowledge of the string used to construct them, and also to
serialize them in cases where alterations have been made to their state
in memory.

Also introduce an option to force complete serialization of a transform
tree (i.e. bypass LoadStore blocks), this allows us to do things like
serialize an algorithm in memory, and transmit it to another process
without requiring that the other process read part of the algorithm from
disk.

Refactor ProcessWrapper to directly transmit its current Transform to
child processes, rather than requiring the child processes to read its
state from disk. This allows for far more uniform treatment of
multiProcess and non-multiProcess jobs in AlgorithmCore, leading to
substantial simplification of AlgorithmCore::compare.

Preliminary support for supplying additional arguments to algorithms

This saves upwards of 3 lines of code!

Sadly, using setPropertyRecursive to set things interacts poorly with
ProcessWrapper (because child processes are constructed as needed, using
a string to build their algorithms) so drop that for now.

Allow users to supply additional arguments to abbreviations or pre-trained
algorithms (e.g. FaceRecogntion(a=b) is now possible).
Arguments supplied must be key/value pairs, not positional. Any listed
additional properties will be assigned to the first matching transform
using a pre-order traversal of the algorithm tree.

This avoids the need for the arguments of GalleryCompare and other
gallery comparison style transforms to be precisely aligned.

Update some brace placements.

Refactor PP5 comparison handling

Introduce PP5GalleryTransform, a transform that compares incoming templates
against a fixed gallery (thereby avoiding the cost of repeatedly setting up
pp5 galleries for the same templates).

Modify AlgorithmCore to support supplying Transforms to the right of the
algorithm string, in this case ! should be used instead of :.

Implement a method for setting properties after objects have been created