Peter M. Groen / openbr

Drop most special casing of parallelism=0, if parallelism=0 is received, set
the max number of threads to 1, and go through the same code as when more
threads are available.

Some outstanding issues, the following transforms are blocked out since they
aren't consistent with this change:
EditTransform
ElicitMetaDataTransform
StasmTransform

In stasm's case, a global mutex must be used, similarly ElicitMetaData reads
from stdin, and would also require a global lock. EditTransform can probably be
reimplemented through Qt similarly to Show

Also, change the default waitKey value to be consistent with original
Show

When doing a const project, using the default CompositeTransform implementation
(with time-varying child transforms), don't make twice as many copies of things
as necessary.

Also, allow stream to use the CompositeTransform const project method.

Now that we are explicitly cloning every frame that we get, releasing
VideoCaptures no longer causes segfaults.

We can just send a close event, then we don't have to worry about new display
events showing the window after we hid it.

Make show2 hide its window if finalize is called, also change the update image
signal to a blocking type to allow this to work correctly (this will actually
lock the frame rate of a stream to whatever speed qt can update windows at, so
maybe should be optional)

After calling VideoCapture::read, make a clone of the returned matrix since it
has become clear that in at least some cases, the returned matrix is an alias
of some internal buffer of the VideoCapture.

Move TimeInvariantTransformWrapper to openbr_internal.h, add a default way
for composite transforms to handle const project calls when they have
time-varying child transforms.

Rather than showing the (empty) window after init is called, wait until
actually told to display an image to show the window.

-algorithm something[distribute=false] prevents the default DistributeTemplate
from being prepended to the transform part of "something"

Give Distribute better support for handling timevarying transforms

Move CompositeTransform, and several other categorical abstract transform types
to a new file, openbr_internal.h. Adjust files in plugins to include the new
file rather than incldue openbr_plugin.h directly.

Introduce 'pseudocopy' operation which, which if called on a time-invariant
transform, returns the transform, but if called on a time-varying transform
returns a copy of the current state of the time-varying transform. Composite
transforms apply pseudocopy to their children (if they contain any time-varying
transforms).

Introduce a wrapper class that uses Resource to let time-varying transforms act
like time-invariant transforms, currently only used by distribute (it is
assumed that any work that is being distributed is in fact independent).

This is currently implemented by an event filter on the QApplication, which
isn't great, but I couldn't get a QShortcut to work.

Don't explicitly release the VideoCapture when it runs out of frames, further
investigation is needed, but this seems to cause an overrun or something

Additionally, make TemplateDataSource behave consistently with VideoDataSource,
breaking only after getNext has been called when no further frames are
available.

Since it's actually a distance, being named KeyPointMatcherTransform prevented
name lookup from working correctly