Peter M. Groen / openbr

currently being used backwards during evaluation

basic support for online video processing

Add Show2Transform (should replace ShowTransform eventually), which displays
input images using QT, rather than going through openCV.
Additional modifications to support doing this (since qt is quite particular
about how GUI elements are created/modified). Create a QApplication instead
of a QCoreApplication (if not building BR_EMBEDDED), restructure br.cpp's main
to run its main work in a separate thread while the main thread sits in an
event loop.

Add StreamTransform which represents applying a series of transforms to some
sequential input (e.g. a video). Handles reading video frames in and processing
them as they become available (rather than loading the entire video into memory
before processing it). The basic idea is a pipeline model, every child
transform of StreamTransform is run by a separate thread, (as is reading in
video frames). A thread waits for a frame as input, when input becomes
available performs its operation, and then places the frame on the following
stage's input buffer. Single threaded processing is not yet implemented.

Moved CompositeTransform to openbr_plugin.h
Add ContractTransform -- combines all input templates into a single template
Preliminary handling of time varying transforms in DistributeTemplateTransform,
the current behavior is not actually correct but will work for the single input
case.

Structural changes to the basic multi-template enrollment operation

Make a call to qSort prior to shuffling the records received by a dbGallery
this makes the output of a dbGallery deterministic for a given query (as long
as the seed is set).

Handle enrollment of multiple independent templates by creating a single
element template list from each input template, then processing these
TemplateLists in parallel. This changes the basic operation for processing
templates derived from a sinlge image from project(template, template) (a
single input/single output function) to project(templateList, templateList),
which allows for a transform to output a variable number of templates from a
given input (e.g. a detector can output multiple templates, or a filter can
remove templates that don't meet some criterion).

The basic parallel execution code loop is implemented using
DistributeTemplateTransform, instead of through Template::Project(list), and a DistributeTemplateTransform is automatically prepended to input enrollment
algorithms. This avoids the problem of having to decide whether or not a split
should take place on every call to project(templatelist), and since the
distribute transform is just a normal transform, it can be applied more than
once in a given algorithm (when this is desirable).

Implement ExpandTransform as a basic Transform that take a template list as
input, and expands it for its output (in project(templatelist)), due to the
restructuring ExpandTransform no longer has to essentially mimic the
functionality of PipeTransform to function correctly.

This commit breaks binary compatibility (of saved models), so updates to the
pre-trained face recognition and gender classification models are included.

getBool("X") --> get<bool>("X",false) and appendLandmarks -->
appendPoints