Merge the docs branch into master and some cleanup

Jordan Cheney
2 parents ecf2c294 50c7b69c
Showing 342 changed files with 27891 additions and 4440 deletions
CMakeLists.txt
app/br/br.cpp
docs/DOCS.md
docs/build_docs.sh
docs/docs/api_docs.md
docs/docs/api_docs/c_api.md
docs/docs/api_docs/c_api/functions.md
docs/docs/api_docs/c_api/typedefs.md
docs/docs/api_docs/cl_api.md
docs/docs/api_docs/cpp_api.md
docs/docs/api_docs/cpp_api/apifunctions.md
docs/docs/api_docs/cpp_api/classifier/classifier.md
docs/docs/api_docs/cpp_api/classifier/constructors.md
docs/docs/api_docs/cpp_api/classifier/functions.md
docs/docs/api_docs/cpp_api/classifier/statics.md
docs/docs/api_docs/cpp_api/compositetransform/compositetransform.md
docs/docs/api_docs/cpp_api/compositetransform/constructors.md
docs/docs/api_docs/cpp_api/compositetransform/functions.md
docs/docs/api_docs/cpp_api/compositetransform/members.md
docs/docs/api_docs/cpp_api/compositetransform/properties.md
@@ -169,16 +169,6 @@ foreach(DIR ${BR_THIRDPARTY_APPS_DIR})
   add_subdirectory(${DIR} 3rdparty_apps/${FNAME})
 endforeach()
-# Build the documentation?
-option(BR_BUILD_DOCUMENTATION "Build Documentation (Requires doxygen and latex)")
-if(${BR_BUILD_DOCUMENTATION})
-  find_package(Doxygen REQUIRED)
-  configure_file(${BR_SHARE_DIR}/Doxyfile.in Doxyfile)
-  add_custom_target(doc ALL ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/share/openbr/MBGC_file_overview.pdf ${CMAKE_CURRENT_BINARY_DIR}/html/MBGC_file_overview.pdf COPYONLY)
-  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION .)
-endif()
-
 # Install
 install(FILES CHANGELOG.md LICENSE.txt README.md DESTINATION share/openbr)
 install(DIRECTORY share DESTINATION .)
@@ -257,19 +257,22 @@ private:
                "-train <gallery> ... <gallery> [{model}]\n"
                "-enroll <input_gallery> ... <input_gallery> {output_gallery}\n"
                "-compare <target_gallery> <query_gallery> [{output}]\n"
+               "-pairwiseCompare <target_gallery> <query_gallery> [{output}]\n"
                "-eval <simmat> [<mask>] [{csv}] [{matches}]\n"
+               "-inplaceEval <simmat> <target> <query> [{csv}]\n"
                "-plot <file> ... <file> {destination}\n"
                "\n"
                "==== Other Commands ====\n"
                "-fuse <simmat> ... <simmat> (None|MinMax|ZScore|WScore) (Min|Max|Sum[W1:W2:...:Wn]|Replace|Difference|None) {simmat}\n"
                "-cluster <simmat> ... <simmat> <aggressiveness> {csv}\n"
                "-makeMask <target_gallery> <query_gallery> {mask}\n"
+               "-makePairwiseMask <target_gallery> <query_gallery> {mask}\n"
                "-combineMasks <mask> ... <mask> {mask} (And|Or)\n"
                "-cat <gallery> ... <gallery> {gallery}\n"
                "-convert (Format|Gallery|Output) <input_file> {output_file}\n"
                "-evalClassification <predicted_gallery> <truth_gallery> <predicted property name> <ground truth proprty name>\n"
                "-evalClustering <clusters> <gallery>\n"
-               "-evalDetection <predicted_gallery> <truth_gallery> [{csv}] [{normalize}] [{minSize}]\n"
+               "-evalDetection <predicted_gallery> <truth_gallery> [{csv}] [{normalize}] [{minSize}] [{maxSize}]\n"
                "-evalLandmarking <predicted_gallery> <truth_gallery> [{csv} [<normalization_index_a> <normalization_index_b>] [sample_index] [total_examples]]\n"
                "-evalRegression <predicted_gallery> <truth_gallery> <predicted property name> <ground truth property name>\n"
                "-assertEval <simmat> <mask> <accuracy>\n"
@@ -277,6 +280,7 @@ private:
                "-plotLandmarking <file> ... <file> {destination}\n"
                "-plotMetadata <file> ... <file> <columns>\n"
                "-project <input_gallery> {output_gallery}\n"
+               "-deduplicate <input_gallery> <output_gallery> <threshold>"
                "-getHeader <matrix>\n"
                "-setHeader {<matrix>} <target_gallery> <query_gallery>\n"
                "-<key> <value>\n"
@@ -288,6 +292,7 @@ private:
                "-about\n"
                "-version\n"
                "-daemon\n"
+               "-slave\n"
                "-exit\n");
     }
 };
+# OpenBR Documentation Guide
+
+This is a quick guide for generating the OpenBR documentation on your local machine. The documentation is available online at www.openbiometrics.org.
+
+OpenBR's documentation is built with MkDocs. Please see their website for additional information at www.mkdocs.org. Installing mkdocs with pip is super easy-
+
+    $ pip install mkdocs
+
+Please note that you need Python 2.7 and above already installed. Once mkdocs is installed you can run build_docs.sh to build static html pages at openbr/docs/site. However, for viewing we recommend serving the docs to your browser using a simple http server. Run
+
+    $ mkdocs serve
+
+from openbr/docs and then go to http://127.0.0.1:8000 in your internet browser of choice to view the docs locally.
+# Build the OpenBR documentation as static html
+#
+# NOTE: This requires mkdocs to be installed. Please see DOCS.md file for
+# instructions
+
+mkdocs build --clean
+# API Documentation
+
+OpenBR offers four APIs for your convenience:
+
+* [C API](api_docs/c_api.md)
+* [Command Line API](api_docs/cl_api.md)
+* [Python API](api_docs/python_api.md)
+* [C++ Plugin API](api_docs/cpp_api.md)
+
+Please see the detailed documentation for each to learn more.
+# C API
+
+The C API is a high-level API for running algorithms and evaluating results.
+
+In order to provide a high-level interface that is usable from the command line and callable from other programming languages, the API is designed to operate at the "file system" level.
+In other words, arguments to many functions are file paths that specify either a source of input or a desired output.
+File extensions are relied upon to determine *how* files should be interpreted in the context of the function being called.
+The [C++ Plugin API](cpp_api.md) should be used if more fine-grained control is required.
+
+## Important API Considerations
+
+Name | Consideration
+--- | ---
+<a class="table-anchor" id="memory"></a>Memory | Memory for <tt>const char*</tt> return values is managed internally and guaranteed until the next call to the function
+<a class="table-anchor" id="input-string-buffers"></a>Input String Buffers | Users should input a char * buffer and the size of that buffer. String data will be copied into the buffer, if the buffer is too small, only part of the string will be copied. Returns the buffer size required to contain the complete string.
+
+
+## Using the API
+
+To use the API in your project include the following file:
+
+    #include <openbr/openbr.h>
+
+[CMake](http://www.cmake.org/) developers may wish to the cmake configuration file found at:
+
+    share/openbr/cmake/OpenBRConfig.cmake
+
+Please see the [tutorials](../tutorials.md) section for examples.
+## br_about
+
+Calls [Context](../cpp_api/context/context.md)::[about](../cpp_api/context/statics.md#about).
+
+* **function definition:**
+
+        const char *br_about()
+
+* **parameters:** None
+* **output:** (const char *) Returns a string describing OpenBR
+* **see:** [br_version](#br_version)
+
+---
+
+## br_cat
+
+Concatenates a list of galleries into 1 gallery.
+
+* **function definition:**
+
+        void br_cat(int num_input_galleries, const char *input_galleries[], const char *output_gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_input_galleries | int | Size of input_galleries
+    input_galleries[] | const char * | List of galleries
+    output_gallery | const char * | Pointer to store concatenated gallery
+
+* **output:** void
+* **see:** [Cat](../cpp_api/apifunctions.md#cat)
+
+---
+
+## br_deduplicate
+
+Removes duplicate [templates](../cpp_api/template/template.md) in a [gallery](../cpp_api/gallery/gallery.md). If a galley contains n duplicates, the first n-1 duplicates in the gallery will be removed and the nth will be kept. Users are encouraged to use binary gallery formats as the entire gallery is read into memory in one call to [Gallery](../cpp_api/gallery/gallery.md)::[read](../cpp_api/gallery/functions.md#read).
+
+* **function definition:**
+
+        void br_deduplicate(const char *input_gallery, const char *output_gallery, const char *threshold)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input_gallery | const char * | Gallery to be deduplicated
+    output_gallery | const char * | Deduplicated gallery
+    threshold | const char * | Comparisons with a match score >= this value are designated to be duplicates.
+
+* **output:** (void)
+
+---
+
+## br_cluster
+
+Clusters one or more similarity matrices into a list of subjects. A [similarity matrix](../../tutorials.md#the-evaluation-harness) is a type of [Output](../cpp_api/output/output.md). The current clustering algorithm is a simplified implementation of the algorithm proposed by Zhu et al[^1].
+
+* **function definition:**
+
+        void br_cluster(int num_simmats, const char *simmats[], float aggressiveness, const char *csv)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_simmats | int | Size of **simmats**
+    simmats[] | const char * | Array of [simmat](../../tutorials.md#the-evaluation-harness) composing one large self-similarity matrix arranged in row major order.
+    aggressiveness | float | The higher the aggressiveness the larger the clusters. Suggested range is [0,10]
+    csv | const char * | The cluster results file to generate. Results are stored one row per cluster and use gallery indices.
+
+* **output:** (void)
+
+---
+
+## br_combine_masks
+
+Combines several equal-sized mask matrices. A comparison may not be simultaneously indentified as both a genuine and an imposter by different input masks.
+
+* **function definition:**
+
+    void br_combine_masks(int num_input_masks, const char *input_masks[], const char *output_mask, const char *method)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_input_masks | int | Size of **input_masks**
+    input_masks[] | const char * | Array of [mask matrices](../../tutorials.md#the-evaluation-harness) to combine. All matrices must have the same dimensions.
+    output_mask | const char * | The file to contain the resulting [mask matrix](../../tutorials.md#the-evaluation-harness)
+    method | const char * | Possible values are: <ul><li>And - Ignore comparison if *any* input masks ignore.</li> <li>Or - Ignore comparison if *all* input masks ignore.</li></ul>
+
+* **see:** [br_make_mask](#br_make_mask)
+
+---
+
+## br_compare
+
+Compares each [Template](../cpp_api/template/template.md) in the query [Gallery](../cpp_api/gallery/gallery.md) to each [Template](../cpp_api/template/template.md)  in the target [Gallery](../cpp_api/gallery/gallery.md).
+
+* **function definition:**
+
+        void br_compare(const char *target_gallery, const char *query_gallery, const char *output = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target_gallery | const char * | target_gallery The [Gallery](../cpp_api/gallery/gallery.md) file whose templates make up the columns of the output.
+    query_gallery | const char * | The [Gallery](../cpp_api/gallery/gallery.md) file whose templates make up the rows of the output. A value of '.' reuses the target gallery as the query gallery.
+    output | const char * | (Optional) The [Output](../cpp_api/output/output.md) file to contain the results of comparing the templates. The default behavior is to print scores to the terminal.
+
+* **output:** (void)
+* **see:** br_enroll
+
+---
+
+## br_compare_n
+
+Convenience function for comparing to multiple targets.
+
+* **function definition:**
+
+        void br_compare_n(int num_targets, const char *target_galleries[], const char *query_gallery, const char *output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_targets | int | Size of **target_galleries**
+    target_galleries[] | const char * | Target galleries to compare against
+    query_gallery | const char * | query gallery for comparison.
+    output | const char * | (Optional) [Output](../cpp_api/output/output.md) file to contain the results of comparing the templates. The default behavior is to print scores to the terminal.
+
+* **output:** (void)
+* **see:** br_compare
+
+---
+
+## br_pairwise_compare
+
+DOCUMENT ME!
+
+* **function definition:**
+
+        void br_pairwise_compare(const char *target_gallery, const char *query_gallery, const char *output = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target_gallery | const char * | DOCUMENT ME
+    query_gallery | const char * | DOCUMENT ME
+    output | const char * | DOCUMENT ME
+
+* **output:** (void)
+
+---
+
+## br_convert
+
+Convert a file to a different type. Files can only be converted to types within the same group. For example [formats](../cpp_api/format/format.md) can only be converted to other [formats](../cpp_api/format/format.md).
+
+* **function definition:**
+
+        void br_convert(const char *file_type, const char *input_file, const char *output_file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    file_type | const char * | Type of file to convert. Options are [Format](../cpp_api/format/format.md), [Gallery](../cpp_api/gallery/gallery.md) or [Output](../cpp_api/output/output.md).
+    input_file | const char * | File to convert.
+    output_file | const char * | Output file. Type is determined by the file extension.
+
+* **output:** (void)
+
+---
+
+## br_enroll
+
+Constructs [Template(s)](../cpp_api/template/template.md) from an input.
+
+* **function definition:**
+
+        void br_enroll(const char *input, const char *gallery = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const char * | The [format](../cpp_api/format/format.md) or [gallery](../cpp_api/gallery/gallery.md) to enroll.
+    gallery | const char * | (Optional) The [Gallery](../cpp_api/gallery/gallery.md) file to contain the enrolled templates. By default the gallery will be held in memory and *input* can used as a gallery in [br_compare](#br_compare)
+
+* **output:** (void)
+* **see:** [br_enroll_n](#br_enroll_n)
+
+---
+
+## br_enroll_n
+
+Convenience function for enrolling multiple inputs.
+
+* **function definition:**
+
+        void br_enroll_n(int num_inputs, const char *inputs[], const char *gallery = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_inputs | int | Size of **inputs**.
+    inputs[] | const char * | Array of inputs to enroll.
+    gallery | const char * | (Optional) The [Gallery](../cpp_api/gallery/gallery.md) file to contain the enroll templates.
+
+* **output:** (void)
+* **see:** [br_enroll](#br_enroll)
+
+---
+
+## br_project
+
+A naive alternative to [br_enroll](#br_enroll).
+
+* **function definition:**
+
+        void br_project(const char *input, const char *output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const char * | The [format](../cpp_api/format/format.md) or [gallery](../cpp_api/gallery/gallery.md) to enroll.
+    output | const char * | The [Gallery](../cpp_api/gallery/gallery.md) file to contain the enrolled templates. By default the gallery will be held in memory and *input* can used as a gallery in [br_compare](#br_compare)
+
+* **output:** (void)
+* **see:** [br_enroll](#br_enroll)
+
+---
+
+## br_eval
+
+Creates a **.csv** file containing performance metrics from evaluating the similarity matrix using the mask matrix.
+
+* **function defintion:**
+
+        float br_eval(const char *simmat, const char *mask, const char *csv = "", int matches = 0)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    simmat | const char * | The [simmat](../../tutorials.md#the-evaluation-harness) to use
+    mask | const char * | The [mask](../../tutorials.md#the-evaluation-harness) to use.
+    csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+    matches | int | (Optional) An integer number of matches to output around the EER. Default is 0.
+
+* **output:** (float) Returns the true accept rate (TAR) at a false accept rate (FAR) of one in one thousand
+* **see:** [br_plot](#br_plot)
+
+---
+
+## br_assert_eval
+
+Evaluates the similarity matrix using the mask matrix.  Function aborts if TAR @ FAR = 0.001 does not meet an expected performance value.
+
+* **function definition:**
+
+        void br_assert_eval(const char *simmat, const char *mask, const float accuracy)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    simmat | const char * | The [simmat](../../tutorials.md#the-evaluation-harness) to use
+    mask | const char * | The [mask](../../tutorials.md#the-evaluation-harness)
+    accuracy | const float | Desired true accept rate at false accept rate of one in one thousand.
+
+* **output:** (void)
+
+---
+
+## br_inplace_eval
+
+Creates a **.csv** file containing performance metrics from evaluating the similarity matrix using galleries containing ground truth labels.
+
+* **function definition:**
+
+        float br_inplace_eval(const char * simmat, const char *target, const char *query, const char *csv = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    simmat | const char * | The [simmat](../../tutorials.md#the-evaluation-harness)
+    target | const char * | The name of a gallery containing metadata for the target set.
+    query | const char * | The name of a gallery containing metadata for the query set.
+    csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+
+* **output:** (float) Returns the true accept rate (TAR) at a false accept rate (FAR) of one in one thousand
+* **see:** [br_plot](#br_plot)
+
+---
+
+## br_eval_classification
+
+Evaluates and prints classification accuracy to terminal.
+
+* **function definition:**
+
+        void br_eval_classification(const char *predicted_gallery, const char *truth_gallery, const char *predicted_property = "", const char *truth_property = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    predicted_gallery | const char * | The predicted [Gallery](../cpp_api/gallery/gallery.md).
+    truth_gallery | const char * | The ground truth [Gallery](../cpp_api/gallery/gallery.md).
+    predicted_property | const char * | (Optional) Which metadata key to use from the **predicted_gallery**.
+    truth_property | const char * | (Optional) Which metadata key to use from the **truth_gallery**.
+
+* **output:** (void)
+
+---
+
+## br_eval_clustering
+
+Evaluates and prints clustering accuracy to the terminal.
+
+* **function definition:**
+
+        void br_eval_clustering(const char *csv, const char *gallery, const char * truth_property)
+
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+csv | const char * | The cluster results file.
+gallery | const char * | The [Gallery](../cpp_api/gallery/gallery.md) used to generate the [simmat](../../tutorials.md#the-evaluation-harness) that was clustered.
+truth_property | const char * | (Optional) which metadata key to use from **gallery**, defaults to Label
+
+* **output:** (void)
+
+---
+
+## br_eval_detection
+
+Evaluates and prints detection accuracy to terminal.
+
+* **function definition:**
+
+        float br_eval_detection(const char *predicted_gallery, const char *truth_gallery, const char *csv = "", bool normalize = false, int minSize = 0, int maxSize = 0)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    predicted_gallery | const char * | The predicted [Gallery](../cpp_api/gallery/gallery.md).
+    truth_gallery | const char * | The ground truth [Gallery](../cpp_api/gallery/gallery.md).
+    csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+    normalize | bool | (Optional) Flag to normalize predicted bounding boxes for improved detection. Defaults to false.
+    minSize | int | (Optional) Minimum size of faces to be considered in the evaluation. Size is applied to predicted and ground truth galleries. Defaults to -1 (no minimum size).
+    maxSize | int | (Optional) Maximum size if faces to be considered in the evaluation. Size is applied to predicted and ground truth galleries. Defaults to -1 (no maximum size).
+
+* **output:** (float) Returns the true accept rate (TAR) at a false accept rate (FAR) of one in one thousand
+
+---
+
+## br_eval_landmarking
+
+Evaluates and prints landmarking accuracy to terminal.
+
+* **function definition:**
+
+        float br_eval_landmarking(const char *predicted_gallery, const char *truth_gallery, const char *csv = "", int normalization_index_a = 0, int normalization_index_b = 1, int sample_index = 0, int total_examples = 5)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    predicted_gallery | const char * | The predicted [Gallery](../cpp_api/gallery/gallery.md).
+    truth_gallery | const char * | The ground truth [Gallery](../cpp_api/gallery/gallery.md).
+    csv | const char * | (Optional) The **.csv** file to contain performance metrics.
+    normalization_index_a | int | (Optional) The first index in the list of points to use for normalization. Default is 0.
+    normalization_index_b | int | (Optional) The second index in the list of points to use for normalization. Default is 1.
+    sample_index | int | (Optional) The index for sample landmark image in ground truth gallery. Default = 0.
+    total_examples | int | (Optional) The number of accurate and inaccurate examples to display. Default is 5.
+
+* **output:** (float) Returns the true accept rate (TAR) at a false accept rate (FAR) of one in one thousand
+
+---
+
+## br_eval_regression
+
+Evaluates regression accuracy to disk.
+
+* **function definition:**
+
+        void br_eval_regression(const char *predicted_gallery, const char *truth_gallery, const char *predicted_property = "", const char *truth_property = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    predicted_gallery | const char * | The predicted [Gallery](../cpp_api/gallery/gallery.md)
+    truth_gallery | const char * | The ground truth [Gallery](../cpp_api/gallery/gallery.md)
+    predicted_property | const char * | (Optional) Which metadata key to use from **predicted_gallery**.
+    truth_property | const char * | (Optional) Which metadata key to use from **truth_gallery**.
+
+* **output:** (void)
+
+---
+
+## br_fuse
+
+Perform score level fusion on similarity matrices.
+
+* **function definition:**
+
+        void br_fuse(int num_input_simmats, const char *input_simmats[], const char *normalization, const char *fusion, const char *output_simmat)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_input_simmats | int | Size of **input_simmats**.
+    input_simmats[] | const char * | Array of [simmats](../../tutorials.md#the-evaluation-harness). All simmats must have the same dimensions.
+    normalization | const char * | Valid options are: <ul> <li>None - No score normalization.</li> <li>MinMax - Scores normalized to [0,1].</li> <li>ZScore - Scores normalized to a standard normal curve.</li> </ul>
+    fusion | const char * | Valid options are: <ul> <li>Min - Uses the minimum score.</li> <li>Max - Uses the maximum score.</li> <li>Sum - Sums the scores. Sums can also be weighted: <tt>SumW1:W2:...:Wn</tt>.</li> <li>Replace - Replaces scores in the first matrix with scores in the second matrix when the mask is set.</li> </ul>
+    output_simmat | const char * | [Simmat](../../tutorials.md#the-evaluation-harness) to contain the fused scores.
+
+* **output:** (void)
+
+---
+
+## br_initialize
+
+Initializes the [Context](../cpp_api/context/context.md). Required at the beginning of any OpenBR program.
+
+* **function definition:**
+
+        void br_initialize(int &argc, char *argv[], const char *sdk_path = "", bool use_gui = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    argc | int | Number of command line arguments.
+    argv[] | char * | Array of command line arguments.
+    sdk_path | const char * | (Optional) Path to the OpenBR sdk. If no path is provided OpenBR will try and find the sdk automatically.
+    use_gui | bool | (Optional) Enable OpenBR to use make GUI windows. Default is false.
+
+* **output:** (void)
+* **see:** [br_finalize](#br_finalize)
+
+---
+
+## br_initialize_default
+
+Initializes the [Context](../cpp_api/context/context.md) with default arguments.
+
+* **function definition:**
+
+        void br_initialize_default()
+
+* **parameters:** None
+* **output:** (void)
+* **see:** [br_finalize](#br_finalize)
+
+---
+
+## br_finalize
+
+Finalizes the context. Required at the end of any OpenBR program.
+
+* **function definition:**
+
+        void br_finalize()
+
+* **parameters:** None
+* **output:** (void)
+* **see:** [br_initialize](#br_initialize)
+
+---
+
+## br_is_classifier
+
+Checks if the provided algorithm is a classifier. Wrapper of [IsClassifier](../cpp_api/apifunctions.md#isclassifier).
+
+* **function definition:**
+
+        bool br_is_classifier(const char *algorithm)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    algorithm | const char * | Algorithm to check.
+
+* **output:** (bool) Returns true if the algorithm is a classifier (does not have an associated distance)
+* **see:** [IsClassifier](../cpp_api/apifunctions.md#isclassifier)
+
+---
+
+## br_make_mask
+
+Constructs a [mask](../../tutorials.md#the-evaluation-harness) from target and query inputs.
+
+* **function definition:**
+
+        void br_make_mask(const char *target_input, const char *query_input, const char *mask)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target_input | const char * | The target [Gallery](../cpp_api/gallery/gallery.md)
+    query_input | const char * | The query [Gallery](../cpp_api/gallery/gallery.md)
+    mask | const char * | The file to contain the resulting [mask](../../tutorials.md#the-evaluation-harness).
+
+* **output:** (void)
+* **see:** [br_combine_masks](#br_combine_masks)
+
+---
+
+## br_make_pairwise_mask
+
+Constructs a [mask](../../tutorials.md#the-evaluation-harness) from target and query inputs considering the target and input sets to be definite pairwise comparisons.
+
+* **function definition:**
+
+        void br_make_pairwise_mask(const char *target_input, const char *query_input, const char *mask)
+
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+target_input | const char * | The target [Gallery](../cpp_api/gallery/gallery.md)
+query_input | const char * | The query [Gallery](../cpp_api/gallery/gallery.md)
+mask | const char * | The file to contain the resulting [mask](../../tutorials.md#the-evaluation-harness).
+
+* **output:** (void)
+* **see:** [br_combine_masks](#br_combine_masks)
+
+---
+
+## br_most_recent_message
+
+Returns the most recent line sent to stderr. For information on input string buffers please look [here](../c_api.md#input-string-buffers)
+
+* **function definition:**
+
+        int br_most_recent_message(char * buffer, int buffer_length)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | char * | Buffer to store the last line in.
+    buffer_length | int | Length of the buffer.
+
+* **output:** (int) Returns the required size of the input buffer for the most recent message to fit completely
+* **see:** [br_progress](#br_progress), [br_time_remaining](#br_time_remaining)
+
+---
+
+## br_objects
+
+Returns names and parameters for the requested objects. Each object is newline seperated. Arguments are seperated from the object name with a tab. This function uses [QRegExp][QRegExp] syntax.
+
+* **function definition:**
+
+        int br_objects(char * buffer, int buffer_length, const char *abstractions = ".*", const char *implementations = ".*", bool parameters = true)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | char * | Output buffer for results.
+    buffer_length | int | Length of output buffer.
+    abstractions | const char * | (Optional) Regular expression of the abstractions to search. Default is ".\*".
+    implementations | const char * | (Optional) Regular expression of the implementations to search. Default is ".\*".
+    parameters | bool | (Optional) Include parameters after object name. Default is true.
+
+* **output:** (int) Returns the required size of the input buffer for the returned objects to fit completely
+
+---
+
+## br_plot
+
+Renders recognition performance figures for a set of **.csv** files created by [br_eval](#br_eval).
+
+In order of their output, the figures are:
+1. Metadata table
+2. Receiver Operating Characteristic (ROC)
+3. Detection Error Tradeoff (DET)
+4. Score Distribution (SD) histogram
+5. True Accept Rate Bar Chart (BC)
+6. Cumulative Match Characteristic (CMC)
+7. Error Rate (ERR) curve
+
+Two files will be created:
+ * **destination.R** which is the auto-generated R script used to render the figures.
+ * **destination.pdf** which has all of the figures in one file multi-page file.
+
+OpenBR uses file and folder names to automatically determine the plot legend.
+For example, let's consider the case where three algorithms (<tt>A</tt>, <tt>B</tt>, & <tt>C</tt>) were each evaluated on two datasets (<tt>Y</tt> & <tt>Z</tt>).
+The suggested way to plot these experiments on the same graph is to create a folder named <tt>Algorithm_Dataset</tt> that contains the six <tt>.csv</tt> files produced by br_eval <tt>A_Y.csv</tt>, <tt>A_Z.csv</tt>, <tt>B_Y.csv</tt>, <tt>B_Z.csv</tt>, <tt>C_Y.csv</tt>, & <tt>C_Z.csv</tt>.
+The '<tt>_</tt>' character plays a special role in determining the legend title(s) and value(s).
+In this case, <tt>A</tt>, <tt>B</tt>, & <tt>C</tt> will be identified as different values of type <tt>Algorithm</tt>, and each will be assigned its own color; <tt>Y</tt> & <tt>Z</tt> will be identified as different values of type Dataset, and each will be assigned its own line style.
+Matches around the EER will be displayed if the matches parameter is set in [br_eval](#br_eval).
+
+This function requires a current [R][R] installation with the following packages:
+
+        install.packages(c("ggplot2", "gplots", "reshape", "scales", "jpg", "png"))
+
+* **function definiton:**
+
+        bool br_plot(int num_files, const char *files[], const char *destination, bool show = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_files | int | Number of **.csv** files.
+    files[] | const char * | **.csv** files created using [br_eval](#br_eval).
+    destination | const char * | Basename for the resulting figures.
+    show | bool | Open **destination.pdf** using the system's default PDF viewer. Default is false.
+
+* **output:** (bool) Returns true on success. Returns false on a failure to compile the figures due to a missing, out of date, or incomplete <tt>R</tt> installation.
+* **see:** [br_eval](#br_eval)
+
+---
+
+## br_plot_detection
+
+Renders detection performance figures for a set of **.csv** files created by [br_eval_detection](#br_eval_detection).
+
+In order of their output, the figures are:
+1. Discrete Receiver Operating Characteristic (DiscreteROC)
+2. Continuous Receiver Operating Characteristic (ContinuousROC)
+3. Discrete Precision Recall (DiscretePR)
+4. Continuous Precision Recall (ContinuousPR)
+5. Bounding Box Overlap Histogram (Overlap)
+6. Average Overlap Table (AverageOverlap)
+7. Average Overlap Heatmap (AverageOverlap)
+
+Detection accuracy is measured with *overlap fraction = bounding box intersection / union*.
+When computing *discrete* curves, an overlap >= 0.5 is considered a true positive, otherwise it is considered a false negative.
+When computing *continuous* curves, true positives and false negatives are measured fractionally as *overlap* and *1-overlap* respectively.
+
+This function requires a current [R](http://www.r-project.org/) installation with the following packages:
+
+    install.packages(c("ggplot2", "gplots", "reshape", "scales", "jpg", "png"))
+
+* **function definition:**
+
+        bool br_plot_detection(int num_files, const char *files[], const char *destination, bool show = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_files | int | Number of **.csv** files.
+    files[] | const char * | **.csv** files created using [br_eval_detection](#br_eval_detection).
+    destination | const char * | Basename for the resulting figures.
+    show | bool | Open **destination.pdf** using the system's default PDF viewer. Default is false.
+
+* **output:** (bool) Returns true on success. Returns false on a failure to compile the figures due to a missing, out of date, or incomplete <tt>R</tt> installation.
+* **see:** [br_eval_detection](#br_eval_detection), [br_plot](#br_plot)
+
+---
+
+## br_plot_landmarking
+
+Renders landmarking performance figures for a set of **.csv** files created by [br_eval_landmarking](#br_eval_landmarking).
+
+In order of their output, the figures are:
+1. Cumulative landmarks less than normalized error (CD)
+2. Normalized error box and whisker plots (Box)
+3. Normalized error violin plots (Violin)
+
+Landmarking error is normalized against the distance between two predifined points, usually inter-ocular distance (IOD).
+
+* **function definition:**
+
+        bool br_plot_landmarking(int num_files, const char *files[], const char *destination, bool show = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_files | int | Number of **.csv** files.
+    files[] | const char * | **.csv** files created using [br_eval_landmarking](#br_eval_landmarking).
+    destination | const char * | Basename for the resulting figures.
+    show | bool | Open **destination.pdf** using the system's default PDF viewer. Default is false.
+
+* **output:** (bool) Returns true on success. Returns false on a failure to compile the figures due to a missing, out of date, or incomplete <tt>R</tt> installation.
+* **see:** [br_eval_landmarking](#br_eval_landmarking), [br_plot](#br_plot)
+
+---
+
+## br_plot_metadata
+
+Renders metadata figures for a set of **.csv** files with specified columns.
+
+* **function definition:**
+
+        bool br_plot_metadata(int num_files, const char *files[], const char *columns, bool show = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_files | int | Number of **.csv** files.
+    files[] | const char * | **.csv** files created by enrolling templates to **.csv** metadata files.
+    columns | const char * | ';' seperated list of columns to plot.
+    show | bool | Open **PlotMetadata.pdf** using the system's default PDF viewer.
+
+* **output:** (bool) Returns true on success. Returns false on a failure to compile the figures due to a missing, out of date, or incomplete <tt>R</tt> installation.
+* **see:** [br_plot](#br_plot)
+
+---
+
+## br_progress
+
+Returns current progress from [Context](../cpp_api/context/context.md)::[progress](../cpp_api/context/functions.md#progress).
+
+* **function definition:**
+
+        float br_progress()
+
+* **parameters:** None
+
+* **output:** (float) Returns the completion percentage of the running process
+* **see:** [br_most_recent_message](#br_most_recent_message), [br_time_remaining](#br_time_remaining)
+
+---
+
+## br_read_pipe
+
+Read and parse arguments from a named pipe. Used by the [command line api](../cl_api.md) to implement **-daemon**, generally not useful otherwise. Guaranteed to return at least one argument. For information on managed returned values see [here](../c_api.md#memory)
+
+* **function defintion:**
+
+        void br_read_pipe(const char *pipe, int *argc, char ***argv)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    pipe | const char * | Pipe name
+    argc | int * | Argument count
+    argv | char *** | Argument list
+
+* **output:** (void)
+
+---
+
+## br_scratch_path
+
+Fills the buffer with the value of [Context](../cpp_api/context/context.md)::[scratchPath](../cpp_api/context/statics.md#scratchpath). For information on input string buffers see [here](../c_api.md#input-string-buffers).
+
+* **function defintion:**
+
+        int br_scratch_path(char * buffer, int buffer_length)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | char * | Buffer for scratch path
+    buffer_length | int | Length of buffer.
+
+* **output:** (int) Returns the required size of the input buffer for the most recent message to fit completely
+* **see:** [br_version](#br_version)
+
+---
+
+## br_sdk_path
+
+Returns the full path to the root of the SDK.
+
+* **function definition:**
+
+        const char *br_sdk_path()
+
+* **parameters:** None
+* **output:** (const char *) Returns the full path to the root of the SDK
+* **see:** [br_initialize](#br_initialize)
+
+---
+
+## br_get_header
+
+Retrieve the target and query inputs in the [BEE matrix](../../tutorials.md#the-evaluation-harness) header. For information on managed return values see [here](../c_api.md#memory).
+
+* **function definition:**
+
+        void br_get_header(const char *matrix, const char **target_gallery, const char **query_gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    matrix | const char * | The [BEE matrix](../../tutorials.md#the-evaluation-harness) file to modify
+    target_gallery | const char ** | The matrix target
+    query_gallery | const char ** | The matrix query
+
+* **output:** (void)
+* **set:** [br_set_header](#br_set_header)
+
+---
+
+## br_set_header
+
+Update the target and query inputs in the [BEE matrix](../../tutorials.md#the-evaluation-harness) header.
+
+* **function definition:**
+
+        void br_set_header(const char *matrix, const char *target_gallery, const char *query_gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    matrix | const char * | The [BEE matrix](../../tutorials.md#the-evaluation-harness) file to modify
+    target_gallery | const char ** | The matrix target
+    query_gallery | const char ** | The matrix query
+
+* **output:** (void)
+* **see:** [br_get_header](#br_get_header)
+
+---
+
+## br_set_property
+
+Appends a provided value to the [global metadata](../cpp_api/context/context.md) using a provided key.
+
+* **function definition:**
+
+        void br_set_property(const char *key, const char *value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const char * | Key to append
+    value | const char * | Value to append
+
+* **output:** (void)
+
+---
+
+## br_time_remaining
+
+Returns estimate of time remaining in the current process.
+
+* **function definition:**
+
+        int br_time_remaining()
+
+* **parameters:** None
+* **output:** (int) Returns an estimate of the time remaining
+* **see:** [br_most_recent_message](#br_most_recent_message), [br_progress](#br_progress)
+
+---
+
+## br_train
+
+Trains a provided model's [Transform](../cpp_api/transform/transform.md) and [Distance](../cpp_api/distance/distance.md) on the provided input.
+
+* **function definiton:**
+
+        void br_train(const char *input, const char *model = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const char * | The [Gallery](../cpp_api/gallery/gallery.md) to train on.
+    model | const char * | (Optional) String specifying the binary file to serialize training results to. The trained algorithm can be recovered by using this file as the algorithm. By default the trained algorithm will not be serialized to disk.
+
+* **output:** (void)
+* **see:** [br_train_n](#br_train_n)
+
+---
+
+## br_train_n
+
+Convenience function for training on multiple inputs
+
+* **function definition:**
+
+        void br_train_n(int num_inputs, const char *inputs[], const char *model = "")
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    num_inputs | int | Size of **inputs**
+    inputs[] | const char * | An array of [galleries](../cpp_api/gallery/gallery.md) to train on.
+    model | const char * | (Optional) String specifying the binary file to serialize training results to. The trained algorithm can be recovered by using this file as the algorithm. By default the trained algorithm will not be serialized to disk.
+
+* **output:** (void)
+* **see:** [br_train](#br_train)
+
+---
+
+## br_version
+
+Get the current OpenBR version.
+
+* **function definition:**
+
+        const char *br_version()
+
+* **parameters:** None
+* **output:** (const char *) Returns the current OpenBR version
+* **see:** [br_about](#br_about), [br_scratch_path](#br_scratch_path)
+
+---
+
+## br_slave_process
+
+For internal use via [ProcessWrapperTransform](../../plugin_docs/core.md#processwrappertransform)
+
+* **function definition:**
+
+        void br_slave_process(const char * baseKey)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    baseKey | const char * | base key for the slave process
+
+* **output:** (void)
+
+---
+
+## br_load_img
+
+Load an image from a string buffer. This is an easy way to pass an image in memory from another programming language to openbr.
+
+* **function definition:**
+
+        br_template br_load_img(const char *data, int len)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    data | const char * | The image buffer.
+    len | int | The length of the buffer.
+
+* **output:** ([br_template](typedefs.md#br_template) Returns a [br_template](typedefs.md#br_template) loaded with the provided image
+* **see:** [br_unload_img](#br_unload_img)
+
+---
+
+## br_unload_img
+
+Unload an image to a string buffer. This is an easy way to pass an image from openbr to another programming language.
+
+* **function definition:**
+
+        unsigned char* br_unload_img(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md)
+
+* **output:** (unsigned char*)  Returns a buffer loaded with the image data from tmpl
+* **see:** [br_load_img](#br_load_img)
+
+---
+
+## br_template_list_from_buffer
+
+Deserialize a [TemplateList](../cpp_api/templatelist/templatelist.md) from a buffer. Can be the buffer for a .gal file, since they are just a [TemplateList](../cpp_api/templatelist/templatelist.md) serialized to disk.
+
+* **function definition:**
+
+        br_template_list br_template_list_from_buffer(const char *buf, int len)
+
+* **return type:** br_template_list
+* **parameters:**
+
+Parameter | Type | Description
+--- | --- | ---
+buf | const char * | The buffer.
+len | int | The length of the buffer.
+
+* **output:** ([br_template_list](typedefs.md#br_template_list)) Returns a pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md) created from the buffer.
+
+---
+
+## br_free_template
+
+Free a [Template's](../cpp_api/template/template.md) memory.
+
+* **function definition:**
+
+        void br_free_template(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | br_template | Pointer to the [Template](../cpp_api/template/template.md) to free.
+
+* **output:** (void)
+
+---
+
+## br_free_template_list
+
+Free a [TemplateList's](../cpp_api/templatelist/templatelist.md) memory.
+
+* **function definition:**
+
+        void br_free_template_list(br_template_list tl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tl | [br_template_list](typedefs.md#br_template_list) | Pointer to the [TemplateList](../cpp_api/templatelist/templatelist.md) to free.
+
+* **output:** (void)
+
+---
+
+## br_free_output
+
+Free a [Output's](../cpp_api/output/output.md) memory.
+
+* **function definition:**
+
+        void br_free_output(br_matrix_output output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    output | [br_matrix_output](typedefs.md#br_matrix_output) | Pointer to the[Output](../cpp_api/output/output.md) to free.
+
+* **output:** (void)
+
+---
+
+## br_img_rows
+
+Returns the number of rows in an image.
+
+* **function definition:**
+
+        int br_img_rows(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+
+* **output:** (int) Returns the number of rows in an image
+
+---
+
+## br_img_cols
+
+Returns the number of cols in an image.
+
+* **function definition:**
+
+        int br_img_cols(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+
+* **output:** (int) Returns the number of columns in an image
+
+---
+
+## br_img_channels
+
+Returns the number of channels in an image.
+
+* **function definition:**
+
+        int br_img_channels(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+
+* **output:** (int) Returns the number of channels in an image
+
+---
+
+## br_img_is_empty
+
+Checks if the image is empty.
+
+* **function definition:**
+
+        bool br_img_is_empty(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+
+* **output:** (bool) Returns true if the image is empty, false otherwise.
+
+---
+
+## br_get_filename
+
+Get the name of the [file](../cpp_api/template/members.md#file) of a provided [Template](../cpp_api/template/template.md). For information on input string buffers please see [here](../c_api.md#input-string-buffers)
+
+* **function definition:**
+
+        int br_get_filename(char * buffer, int buffer_length, br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | char * | Buffer to hold the filename
+    buffer_length | int | Length of the buffer
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+
+* **output:** (int) Returns the size of the buffer required to hold the entire file name.
+
+---
+
+## br_set_filename
+
+Set the name of the [file](../cpp_api/template/members.md#file) for a provided [Template](../cpp_api/template/template.md).
+
+* **function definition:**
+
+        void br_set_filename(br_template tmpl, const char *filename)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+    filename | const char * | New filename for the template.
+
+* **output:** (void)
+
+---
+
+## br_get_metadata_string
+
+Get the [metadata](../cpp_api/file/members.md#m_metadata) value as a string for a provided key in a provided [Template](../cpp_api/template/template.md).
+
+* **function definition:**
+
+        int br_get_metadata_string(char * buffer, int buffer_length, br_template tmpl, const char *key)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | char * | Buffer to hold the metadata string.
+    buffer_length | int | length of the buffer.
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md).
+    key | const char * | Key for the metadata lookup
+
+* **output:** (int) Returns the size of the buffer required to hold the entire metadata string
+
+---
+
+## br_enroll_template
+
+Enroll a [Template](../cpp_api/template/template.md) from the C API!
+
+* **function definition:**
+
+        br_template_list br_enroll_template(br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | br_template | Pointer to a [Template](../cpp_api/template/template.md).
+
+* **output:** ([br_template_list](typedefs.md#br_template_list)) Returns a pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+
+---
+
+## br_enroll_template_list
+
+Enroll a [TemplateList](../cpp_api/templatelist/templatelist.md) from the C API!
+
+* **function definition:**
+
+        void br_enroll_template_list(br_template_list tl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tl | [br_template_list](typedefs.md#br_template_list) | Pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+
+* **output:** (void)
+
+---
+
+## br_compare_template_lists
+
+Compare [TemplateLists](../cpp_api/templatelist/templatelist.md) from the C API!
+
+* **function definition:**
+
+        br_matrix_output br_compare_template_lists(br_template_list target, br_template_list query)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target | br_template_list | Pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+    query | br_template_list | Pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+
+
+* **output:** ([br_matrix_output](typedefs.md#br_matrix_output)) Returns a pointer to a [MatrixOutput](../cpp_api/matrixoutput/matrixoutput.md)
+
+---
+
+## br_get_matrix_output_at
+
+Get a value in a provided [MatrixOutput](../cpp_api/matrixoutput/matrixoutput.md).
+
+* **function definition:**
+
+        float br_get_matrix_output_at(br_matrix_output output, int row, int col)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    output | br_matrix_output | Pointer to [MatrixOutput](../cpp_api/matrixoutput/matrixoutput.md)
+    row | int | Row index for lookup
+    col | int | Column index for lookup
+
+* **output:** (float) Returns the value of the [MatrixOutput](../cpp_api/matrixoutput/matrixoutput.md) at the provided indexes.
+
+---
+
+## br_get_template
+
+Get a [Template](../cpp_api/template/template.md) from a [TemplateList](../cpp_api/templatelist/templatelist.md) at a specified index.
+
+* **function definition:**
+
+        br_template br_get_template(br_template_list tl, int index)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tl | [br_template_list](typedefs.md#br_template_list) | Pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+    index | int | Index into the template list. Should be in the range [0,len(tl) - 1].
+
+* **output:** ([br_template](typedefs.md#br_template)) Returns a pointer to a [Template](../cpp_api/template/template.md)
+
+---
+
+## br_num_templates
+
+Get the number of [Templates](../cpp_api/template/template.md) in a [TemplateList](../cpp_api/templatelist/templatelist.md).
+
+* **function definition:**
+
+        int br_num_templates(br_template_list tl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tl | [br_template_list](typedefs.md#br_template_list) | Pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+
+* **output:** (int) Returns the size of the provided [TemplateList](../cpp_api/templatelist/templatelist.md)
+
+---
+
+## br_make_gallery
+
+Initialize a [Gallery](../cpp_api/gallery/gallery.md) from a file.
+
+* **function definition:**
+
+        br_gallery br_make_gallery(const char *gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | const char * | String location of gallery on disk.
+
+* **output:** ([br_gallery](typedefs.md#br_gallery)) Returns a pointer to a [Gallery](../cpp_api/gallery/gallery.md) that has been created from the provided file
+
+---
+
+## br_load_from_gallery
+
+Read a [TemplateList](../cpp_api/templatelist/templatelist.md) from a [Gallery](../cpp_api/gallery/gallery.md).
+
+* **function definition:**
+
+        br_template_list br_load_from_gallery(br_gallery gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | [br_gallery](typedefs.md#br_gallery) | Pointer to a [Gallery](../cpp_api/gallery/gallery.md)
+
+* **output:** ([br_template_list](typedefs.md#br_template_list)) Returns a pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md) containing the data from the provided [Gallery](../cpp_api/gallery/gallery.md)
+
+---
+
+## br_add_template_to_gallery
+
+Write a [Template](../cpp_api/template/template.md) to a [Gallery](../cpp_api/gallery/gallery.md)
+
+* **function definition:**
+
+        void br_add_template_to_gallery(br_gallery gallery, br_template tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | [br_gallery](typedefs.md#br_gallery) | Pointer to a [Gallery](../cpp_api/gallery/gallery.md)
+    tmpl | [br_template](typedefs.md#br_template) | Pointer to a [Template](../cpp_api/template/template.md)
+
+* **output:** (void)
+
+---
+
+## br_add_template_list_to_gallery
+
+Write a [TemplateList](../cpp_api/templatelist/templatelist.md) to the [Gallery](../cpp_api/gallery/gallery.md) on disk.
+
+* **function definition:**
+
+        void br_add_template_list_to_gallery(br_gallery gallery, br_template_list tl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | [br_gallery](typedefs.md#br_gallery) | Pointer to a [Gallery](../cpp_api/gallery/gallery.md)
+    tl | [br_template_list](typedefs.md#br_template_list) | Pointer to a [TemplateList](../cpp_api/templatelist/templatelist.md)
+
+* **output:** (void)
+
+---
+
+## br_close_gallery
+
+Close a provided [Gallery](../cpp_api/gallery/gallery.md).
+
+* **function definition:**
+
+        void br_close_gallery(br_gallery gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | [br_gallery](typedefs.md#br_gallery) | Pointer to a [Gallery](../cpp_api/gallery/gallery.md)
+
+* **output:** (void)
+
+[^1]: *Zhu et al.*
+    **A Rank-Order Distance based Clustering Algorithm for Face Tagging**,
+    CVPR 2011
+
+<!-- Links -->
+[R]: http://www.r-project.org/ "R"
+[QRegExp]: http://doc.qt.io/qt-5/QRegExp.html "QRegExp"
+## void *br_template {: #br_template }
+
+## void *br_template_list {: #br_template_list }
+
+## void *br_gallery {: #br_gallery }
+
+## void *br_matrix_output {: #br_matrix_output }
+The command line API is a tool to run OpenBR from the command line. The command line is the easiest and fastest way to run OpenBR!
+
+The following is a detailed description of the command line API. The command line API is really just a set of wrappers to call the [C API](c_api.md). All of the flags in this API have a corresponding C API call. To help display the examples the following shorthand definitions will be used:
+
+Shortcut | Definition
+--- | ---
+&lt;arg&gt; | &lt;&gt; Represent an input argument
+\{arg\} | \{\} Represent an output argument
+[arg] | [] Represent an optional argument
+(arg0 &#124; ... &#124; argN) | (... &#124; ...) Represent a choice.
+
+## Algorithms
+
+Almost every command line process needs to specify an algorithm to work properly. Algorithms in OpenBR are described in detail [here](../tutorials.md#algorithms-in-openbr). To specify algorithms to the command line use the <tt>-algorithm</tt> flag like so:
+
+        -algorithm "AlgorithmString"
+
+Make sure you use the quotes if your algorithm is longer than one plugin because special characters in OpenBR are also special characters (with very different meanings!) in Bash.
+
+## Core Commands
+
+### -train {: #train }
+
+Train a model
+
+* **arguments:**
+
+        -train <gallery> ... <gallery> [{model}]
+
+* **wraps:** [br_train_n](c_api/functions.md#br_train_n)
+
+### -enroll {: #enroll }
+
+Enroll a [Gallery](cpp_api/gallery/gallery.md) through an algorithm
+
+* **arguments:**
+
+        -enroll <input_gallery> ... <input_gallery> {output_gallery}
+
+* **wraps:** [br_enroll](c_api/functions.md#br_enroll) or [br_enroll_n](c_api/functions.md#br_enroll_n) depending on the input size
+
+### -compare {: #compare }
+
+Compare query [Templates](cpp_api/template/template.md) against a target [Gallery](cpp_api/gallery/gallery.md)
+
+* **arguments:**
+
+        -compare <target_gallery> <query_gallery> [{output}]
+
+* **wraps:** [br_compare](c_api/functions.md#br_compare)
+
+### -pairwiseCompare {: #pairwisecompare }
+
+DOCUMENT ME
+
+* **arguments:**
+
+        -pairwiseCompare <target_gallery> <query_gallery> [{output}]
+
+* **wraps:** [br_pairwise_compare](c_api/functions.md#br_pairwise_compare)
+
+### -eval {: #eval }
+
+Evaluate a similarity matrix
+
+* **arguments:**
+
+        -eval <simmat> [<mask>] [{csv}] [{matches}]
+
+* **wraps:** [br_eval](c_api/functions.md#br_eval)
+
+### -inplaceEval {: #inplaceeval }
+
+DOCUMENT ME
+
+* **arguments:**
+
+        -inplaceEval <simmat> <target> <query> [{output}]
+
+* **wraps:** [br_inplace_eval](c_api/functions.md#br_inplace_eval)
+
+### -plot {: #inplaceeval}
+
+Plot the results of an evaluation
+
+* **arguments:**
+
+               -plot <file> ... <file> {destination}
+
+* **wraps:** [br_plot](c_api/functions.md#br_plot)
+
+
+## Other Commands
+
+### -fuse {: #fuse }
+
+Perform score level fusion on similarity matrices.
+
+* **arguments:**
+
+        -fuse <simmat> ... <simmat> (None|MinMax|ZScore|WScore) (Min|Max|Sum[W1:W2:...:Wn]|Replace|Difference|None) {simmat}
+
+* **wraps:** [br_fuse](c_api/functions.md#br_fuse)
+
+### -cluster {: #cluster }
+
+Clusters one or more similarity matrices into a list of subjects
+
+* **arguments:**
+
+        -cluster <simmat> ... <simmat> <aggressiveness> {csv}
+
+* **wraps:** [br_cluster](c_api/functions.md#br_cluster)
+
+### -makeMask {: #makemask }
+
+Constructs a mask from target and query inputs
+
+* **arguments:**
+
+        -makeMask <target_gallery> <query_gallery> {mask}
+
+* **wraps:** [br_make_mask](c_api/functions.md#br_make_mask)
+
+### -makePairwiseMask {: #makepairwisemask }
+
+Constructs a mask from target and query inputs considering the target and input sets to be definite pairwise comparisons.
+
+* **arguments:**
+
+        -makePairwiseMask <target_gallery> <query_gallery> {mask}
+
+* **wraps:** [br_make_pairwise_mask](c_api/functions.md#br_make_pairwise_mask)
+
+### -combineMasks {: #combinemask }
+
+Combines several equal-sized mask matrices. A comparison may not be simultaneously indentified as both a genuine and an imposter by different input masks.
+
+* **arguments:**
+
+        -combineMasks <mask> ... <mask> {mask} (And|Or)
+
+* **wraps:** [br_combine_masks](c_api/functions.md#br_combine_masks)
+
+### -cat {: #cat }
+
+Concatenates a list of galleries into 1 gallery
+
+* **arguments:**
+
+        -cat <gallery> ... <gallery> {gallery}
+
+* **wraps:** [br_cat](c_api/functions.md#br_cat)
+
+### -convert {: #convert }
+
+Convert a file to a different type. Files can only be converted to types within the same group. For example formats can only be converted to other formats.
+
+* **arguments:**
+
+        -convert (Format|Gallery|Output) <input_file> {output_file}
+
+* **wraps:** [br_convert](c_api/functions.md#br_convert)
+
+### -evalClassification {: #evalclassification }
+
+Evaluates and prints classification accuracy to terminal
+
+* **arguments:**
+
+        -evalClassification <predicted_gallery> <truth_gallery> <predicted property name> <ground truth property name>
+
+* **wraps:** [br_eval_classification](c_api/functions.md#br_eval_classification)
+
+### -evalClustering {: #evalclustering }
+
+Evaluates and prints clustering accuracy to the terminal
+
+* **arguments:**
+
+        -evalClustering <clusters> <gallery>
+
+* **wraps:** [br_eval_clustering](c_api/functions.md#br_eval_clustering)
+
+### -evalDetection {: #evaldetection }
+
+Evaluates and prints detection accuracy to terminal
+
+* **arguments:**
+
+        -evalDetection <predicted_gallery> <truth_gallery> [{csv}] [{normalize}] [{minSize}] [{maxSize}]
+
+* **wraps:** [br_eval_detection](c_api/functions.md#br_eval_detection)
+
+### -evalLandmarking {: #evallandmarking }
+
+Evaluates and prints landmarking accuracy to terminal
+
+* **arguments:**
+
+        -evalLandmarking <predicted_gallery> <truth_gallery> [{csv} [<normalization_index_a> <normalization_index_b>] [sample_index] [total_examples]]
+
+* **wraps:** [br_eval_landmarking](c_api/functions.md#br_eval_landmarking)
+
+
+### -evalRegression {: #evalregression }
+
+Evaluates regression accuracy to disk
+
+* **arguments:**
+
+        -evalRegression <predicted_gallery> <truth_gallery> <predicted property name> <ground truth property name>
+
+* **wraps:** [br_eval_regression](c_api/functions.md#br_eval_regression)
+
+### -assertEval {: #asserteval }
+
+Evaluates the similarity matrix using the mask matrix.  Function aborts if TAR @ FAR = 0.001 does not meet an expected performance value.
+
+* **arguments:**
+
+        -assertEval <simmat> <mask> <accuracy>
+
+* **wraps:** [br_assert_eval](c_api/functions.md#br_assert_eval)
+
+### -plotDetection {: #plotdetection }
+
+Renders detection performance figures for a set of .csv files created by [-evalDetection](#evaldetection).
+
+* **arguments:**
+
+        -plotDetection <file> ... <file> {destination}
+
+* **wraps:** [br_plot_detection](c_api/functions.md#br_plot_detection)
+
+### -plotLandmarking {: #plotlandmarking }
+
+Renders landmarking performance figures for a set of .csv files created by [-evalLandmarking](#evallandmarking)
+
+* **arguments:**
+
+        -plotLandmarking <file> ... <file> {destination}
+
+* **wraps:** [br_plot_landmarking](c_api/functions.md#br_plot_landmarking)
+
+### -plotMetadata {: #plotmetadata }
+
+Renders metadata figures for a set of .csv files with specified columns
+
+* **arguments:**
+
+        -plotMetadata <file> ... <file> <columns>
+
+* **wraps:** [br_plot_metadata](c_api/functions.md#br_plot_metadata)
+
+### -project {: #project }
+
+A naive alternative to [-enroll](#enroll)
+
+* **arguments:**
+
+        -project <input_gallery> {output_gallery}
+
+* **wraps:** [br_project](c_api/functions.md#br_project)
+
+### -getHeader {: #getheader }
+
+Retrieve the target and query inputs in the [BEE matrix](../tutorials.md#the-evaluation-harness) header
+
+* **arguments:**
+
+        -getHeader <matrix>
+
+* **wraps:** [br_get_header](c_api/functions.md#br_get_header)
+
+### -setHeader {: #setheader }
+
+Update the target and query inputs in the [BEE matrix](../tutorials.md#the-evaluation-harness) header
+
+* **arguments:**
+
+        -setHeader {<matrix>} <target_gallery> <query_gallery>
+
+* **wraps:** [br_set_header](c_api/functions.md#br_set_header)
+
+### -&lt;key&gt; &lt;value&gt; {: #setproperty }
+
+Appends a provided value to the [global metadata](cpp_api/context/context.md) using a provided key
+
+* **arguments:**
+
+        -<key> <value>
+
+* **wraps:** [br_set_property](c_api/functions.md#br_set_property)
+
+
+## Miscellaneous
+
+### -help {: #help }
+
+Print command line API documentation to the terminal
+
+* **arguments:**
+
+        -help
+
+* **wraps:** N/A
+
+### -gui {: #gui }
+
+If this flag is set OpenBR will enable GUI windows to be launched. It must be the first flag set.
+
+* **arguments:**
+
+        br -gui
+
+* **wraps:** N/A
+
+### -objects {: #objects }
+
+Returns names and parameters for the requested objects. Each object is newline separated. Arguments are separated from the object name with a tab. This function uses [QRegExp][QRegExp] syntax
+
+* **arguments:**
+
+        -objects [abstraction [implementation]]
+
+* **wraps:** [br_objects](c_api/functions.md#br_objects)
+
+### -about {: #about }
+
+Get a string with the name, version, and copyright of the project. This string is suitable for printing or terminal
+
+* **arguments:**
+
+        -about
+
+* **wraps:** [br_about](c_api/functions.md#br_about)
+
+### -version {: #version }
+
+Get the current OpenBR version
+
+* **arguments:**
+
+        -version
+
+* **wraps:** [br_version](c_api/functions.md#br_version)
+
+### -slave {: #slave }
+
+For internal use via [ProcessWrapperTransform](../plugin_docs/core.md#processwrappertransform)
+
+* **arguments:**
+
+        -slave <baseKey>
+
+* **wraps:** [br_slave_process](c_api/functions.md#br_slave_process)
+
+### -daemon {: #daemon }
+
+DOCUMENT ME
+
+* **arguments:**
+
+        -daemon <daemon_pipe>
+
+* **wraps:** N/A
+
+### -exit
+
+Exit the application
+
+* **arguments:**
+
+        -exit
+
+* **wraps:** N/A
+
+<!-- Link -->
+[QRegExp]: http://doc.qt.io/qt-5/QRegExp.html "QRegExp"
+# C++ Plugin API
+
+The C++ Plugin API is a pluggable API designed to allow the succinct expression of biometrics algorithms as a series of independent plugins. The API exposes a number of data structures and plugin abstractions to use as simple building blocks for complex algorithms.
+
+## Data Structures
+
+The API defines two data structures:
+
+* [File](cpp_api/file/file.md)s are typically used to store the path to a file on disk with associated metadata (in the form of key-value pairs). In the example above, we store the rectangles detected by [Cascade](../plugin_docs/metadata.md#cascadetransform) as metadata which are then used by [Draw](../plugin_docs/gui.md#drawtransform) for visualization.
+* [Template](cpp_api/template/template.md)s are containers for images and [File](cpp_api/file/file.md)s. Images in OpenBR are OpenCV Mats and are member variables of Templates. Templates can contain one or more images.
+
+## Plugin Abstractions
+
+A plugin in OpenBR is defined as *classes which modify, interpret, or assist with the modification of OpenBR compatible images and/or metadata*. All OpenBR plugins have a common ancestor, [Object](cpp_api/object/object.md), and they all are constructed from string descriptions given by [Files](cpp_api/file/file.md). There are eight base abstractions that derive from [Object](cpp_api/object/object.md), one of which should be the parent for all production plugins. They are:
+
+Plugin | Function
+--- | ---
+[Initializer](cpp_api/initializer/initializer.md) | Initializes shared contexts and variables at the launch of OpenBR. Typically used with third-party plugins.
+[Transform](cpp_api/transform/transform.md) | The most common plugin type in OpenBR. Provides the basis for algorithms by transforming images or metadata.
+[Distance](cpp_api/distance/distance.md) | Used to compute a distance metric between [Template](cpp_api/template/template.md)s.
+[Format](cpp_api/format/format.md) | Used for I/O. Formats handle file types that correspond to single objects (e.g. .jpg, .png, etc.).
+[Gallery](cpp_api/gallery/gallery.md) | Used for I/O. Galleries handle file types that correspond to many objects (e.g. .csv., .xml, etc.).
+[Output](cpp_api/output/output.md) | Used for I/O. Outputs handle the results of [Distance](cpp_api/distance/distance.md) comparisons.
+[Representation](cpp_api/representation/representation.md) | Converts images into feature vectors. Slightly different then [Transform](cpp_api/transform/transform.md)s in implementation and available API calls.
+[Classifier](cpp_api/classifier/classifier.md) | Classifies feature vectors as members of specific classes or performs regression on them.
+
+ Additionally, there are several child-abstractions for specific use cases. A few examples are:
+
+ Plugin | Parent | Function
+ --- | --- | ---
+ [UntrainableTransform](cpp_api/untrainabletransform/untrainabletransform.md) | [Transform](cpp_api/transform/transform.md) | A [Transform](cpp_api/transform/transform.md) that cannot be trained.
+ [MetaTransform](cpp_api/metatransform/metatransform.md) | [Transform](cpp_api/transform/transform.md)  | A [Transform](cpp_api/transform/transform.md) that is *not* [independent](cpp_api/transform/members.md#independent).
+ [UntrainableMetaTransform](cpp_api/untrainablemetatransform/untrainablemetatransform.md) | [UntrainableTransform](cpp_api/untrainabletransform/untrainabletransform.md) | A [Transform](cpp_api/transform/transform.md) that is *not* [independent](cpp_api/transform/members.md#independent) and cannot be trained.
+ [MetadataTransform](cpp_api/metadatatransform/metadatatransform.md) | [Transform](cpp_api/transform/transform.md) | A [Transform](cpp_api/transform/transform.md) that operates only on [Template](cpp_api/template/template.md) [metadata](cpp_api/template/members.md#file).
+ [TimeVaryingTransform](cpp_api/timevaryingtransform/timevaryingtransform.md) | [Transform](cpp_api/transform/transform.md) | A [Transform](cpp_api/transform/transform.md) that changes at runtime as a result of the input.
+ [UntrainableDistance](cpp_api/untrainabledistance/untrainabledistance.md) | [Distance](cpp_api/distance/distance.md) | A [Distance](cpp_api/distance/distance.md) that cannot be trained.
+ [MatrixOutput](cpp_api/matrixoutput/matrixoutput.md) | [Output](cpp_api/output/output.md) | A [Output](cpp_api/output/output.md) that outputs data as a matrix.
+
+ As previously mentioned, all plugins in OpenBR are constructed using strings stored as [Files](cpp_api/file/file.md). The construction is done at runtime by a [Factory](cpp_api/factory/factory.md) class[^1]. The [Factory](cpp_api/factory/factory.md) expects strings of the form `PluginName(property1=value1,property2=value2...propertyN=valueN)` (value lists are also permitted). It looks up the `PluginName` in a static registry and builds the plugin if found. The registry is populated using a special macro [BR_REGISTER](cpp_api/factory/macros.md#br_register); each plugin needs to register itself and its base abstraction in the factory to enable construction. The purpose of this is to allow algorithms to be described completely by strings. For more information on algorithms in OpenBR please see the [tutorial](../tutorials.md#algorithms-in-openbr)
+
+[^1]: [Industrial Strength Pluggable Factories](https://adtmag.com/articles/2000/09/25/industrial-strength-pluggable-factories.aspx)
+<!-- API FUNCTIONS -->
+
+## IsClassifier {: #isclassifier }
+
+Determines if the given algorithm is a classifier. A classifier is defined as a [Transform](transform/transform.md) with no associated [Distance](distance/distance.md). Instead metadata fields with the predicted output classes are populated in [Template](template/template.md) [files](template/members.md#file).
+
+* **function definition:**
+
+        bool IsClassifier(const QString &algorithm)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    algorithm | const [QString][QString] & | Algorithm to evaluate
+
+* **output:** (bool) True if the algorithm is a classifier and false otherwise
+* **see:** [br_is_classifier](../c_api/functions.md#br_is_classifier)
+* **example:**
+
+        IsClassifier("Identity"); // returns true
+        IsClassifier("Identity:Dist"); // returns false
+
+---
+
+## Train {: #train }
+
+High level function for creating models.
+
+* **function definition:**
+
+        void Train(const File &input, const File &model)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const [File](file/file.md) & | Training data
+    model | const [File](file/file.md) & | Model file
+
+* **output:** (void)
+* **see:** The [training tutorial](../../tutorials.md#training-algorithms) for an example of training.
+* **example:**
+
+        File file("/path/to/images/or/gallery.gal");
+        File model("/path/to/model/file");
+        Train(file, model);
+
+---
+
+## Enroll {: #enroll-1 }
+
+High level function for creating [galleries](gallery/gallery.md).
+
+* **function definition:**
+
+        void Enroll(const File &input, const File &gallery = File())
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const [File](file/file.md) & | Path to enrollment file
+    gallery | const [File](file/file.md) & | (Optional) Path to gallery file.
+
+* **output:** (void)
+* **see:** [br_enroll](../c_api/functions.md#br_enroll)
+* **example:**
+
+        File file("/path/to/images/or/gallery.gal");
+        Enroll(file); // Don't need to specify a gallery file
+        File gallery("/path/to/gallery/file");
+        Enroll(file, gallery); // Will write to the specified gallery file
+
+---
+
+## Enroll {: #enroll-2 }
+
+High level function for enrolling templates. Templates are modified in place as they are projected through the algorithm.
+
+* **function definition:**
+
+        void Enroll(TemplateList &tmpl)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tmpl | [TemplateList](templatelist/templatelist.md) & | Data to enroll
+
+* **output:** (void)
+* **example:**
+
+        TemplateList tList = TemplateList() << Template("picture1.jpg")
+                                            << Template("picture2.jpg")
+                                            << Template("picture3.jpg");
+        Enroll(tList);
+
+---
+
+## Project {: #project}
+
+A naive alternative to [Enroll](#enroll-1).
+
+* **function definition:**
+
+        void Project(const File &input, const File &output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    input | const [File](file/file.md) & | Path to enrollment file
+    gallery | const [File](file/file.md) & | Path to gallery file.
+
+* **output:** (void)
+* **see:** [Enroll](#enroll-1)
+* **example:**
+
+        File file("/path/to/images/or/gallery.gal");
+        File output("/path/to/gallery/file");
+        Project(file, gallery); // Will write to the specified gallery file
+
+---
+
+## Compare {: #compare }
+
+High level function for comparing galleries. Each template in the **queryGallery** is compared against every template in the **targetGallery**.
+
+* **function definition:**
+
+        void Compare(const File &targetGallery, const File &queryGallery, const File &output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetGallery | const [File](file/file.md) & | Gallery of target templates
+    queryGallery | const [File](file/file.md) & | Gallery of query templates
+    output | const [File](file/file.md) & | Output file for results
+
+* **returns:** (output)
+* **see:** [br_compare](../c_api/functions.md#br_compare)
+* **example:**
+
+        File target("/path/to/target/images/");
+        File query("/path/to/query/images/");
+        File output("/path/to/output/file");
+        Compare(target, query, output);
+
+---
+
+## CompareTemplateList {: #comparetemplatelists}
+
+High level function for comparing templates.
+
+* **function definition:**
+
+        void CompareTemplateLists(const TemplateList &target, const TemplateList &query, Output *output);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target | const [TemplateList](templatelist/templatelist.md) & | Target templates
+    query | const [TemplateList](templatelist/templatelist.md) & | Query templates
+    output | [Output](output/output.md) \* | Output file for results
+
+* **output:** (void)
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target_img1.jpg")
+                                              << Template("target_img2.jpg")
+                                              << Template("target_img3.jpg");
+
+        TemplateList query = TemplateList() << Template("query_img.jpg");
+        Output *output = Factory::make<Output>("/path/to/output/file");
+
+        CompareTemplateLists(targets, query, output);
+
+---
+
+## PairwiseCompare {: #pairwisecompare }
+
+High level function for doing a series of pairwise comparisons.
+
+* **function definition:**
+
+        void PairwiseCompare(const File &targetGallery, const File &queryGallery, const File &output)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetGallery | const [File](file/file.md) & | Gallery of target templates
+    queryGallery | const [File](file/file.md) & | Gallery of query templates
+    output | const [File](file/file.md) & | Output file for results  
+
+* **output:** (void)
+* **see:** [br_pairwise_comparison](../c_api/functions.md#br_pairwise_compare)
+* **example:**
+
+        File target("/path/to/target/images/");
+        File query("/path/to/query/images/");
+        File output("/path/to/output/file");
+        PairwiseCompare(target, query, output);
+
+---
+
+## Convert {: #convert }
+
+Change the format of the **inputFile** to the format of the **outputFile**. Both the **inputFile** format and the **outputFile** format must be of the same format group, which is specified by the **fileType**.
+
+* **function definition:**
+
+        void Convert(const File &fileType, const File &inputFile, const File &outputFile)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    fileType | const [File](file/file.md) & | Can be either: <ul> <li>[Format](format/format.md)</li> <li>[Gallery](gallery/gallery.md)</li> <li>[Output](output/output.md)</li> </ul>
+    inputFile | const [File](file/file.md) & | File to be converted. Format is inferred from the extension.
+    outputFile | const [File](file/file.md) & | File to store converted input. Format is inferred from the extension.
+
+* **output:** (void)
+* **example:**
+
+        File input("input.csv");
+        File output("output.xml");
+        Convert("Format", input, output);
+
+---
+
+## Cat {: #cat }
+
+Concatenate several galleries into one.
+
+* **function definition:**
+
+        void Cat(const QStringList &inputGalleries, const QString &outputGallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    inputGalleries | const [QStringList][QStringList] & | List of galleries to concatenate
+    outputGallery | const [QString][QString] & | Gallery to store the concatenated result. This gallery cannot be in the inputGalleries
+
+* **output:** (void)
+* **see:** [br_cat](../c_api/functions.md#br_cat)
+* **example:**
+
+        QStringList inputGalleries = QStringList() << "/path/to/gallery1"
+                                                   << "/path/to/gallery2"
+                                                   << "/path/to/gallery3";
+
+        QString outputGallery = "/path/to/outputGallery";
+        Cat(inputGalleries, outputGallery);
+
+---
+
+## Deduplicate {: #deduplicate }
+
+Deduplicate a gallery. A duplicate is defined as an image with a match score above a given threshold to another image in the gallery.
+
+* **function definition:**
+
+        void Deduplicate(const File &inputGallery, const File &outputGallery, const QString &threshold)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    inputGallery | const [File](file/file.md) & | Gallery to deduplicate
+    outputGallery | const [File](file/file.md) & | Gallery to store the deduplicated result
+    threshold | const [QString][QString] & | Match score threshold to determine duplicates
+
+* **output:** (void)
+* **see:** [br_deduplicate](../c_api/functions.md#br_deduplicate)
+* **example:**
+
+        File input("/path/to/input/galley/with/dups");
+        File output("/path/to/output/gallery");
+        Deduplicate(input, output, "0.7"); // Remove duplicates with match scores above 0.7
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+<!-- CLASSIFIER -->
+
+Inherits [Object](../object/object.md)
+
+See:
+
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+Classifiers are used to assign images to a specific class, or to a particular value along a regression line.  Although [Transforms](../transform/transform.md) can also be used for this purpose, [Classifiers](classifier.md) provide a simpler and more consistent API.
+Constructor / Destructor | Description
+--- | ---
+virtual ~Classifier() | Default destructor. It doesn' do anything.
+## void train(const [QList][QList]&lt;[Mat][Mat]&gt; &images, const [QList][QList]&lt;float&gt; &labels) {: #train }
+
+This is a pure, virtual function. Train the classifier using the provided images and labels.
+
+* **function definition:**
+
+        virtual void train(const QList<Mat> &images, const QList<float> &labels) = 0
+
+* **parameters:**
+
+    Parameter | Type | Descriptions
+    --- | --- | ---
+    images | const [QList][QList]&lt;[Mat][Mat]&gt; & | Training images
+    labels | const [QList][QList]&lt;float&gt; & | Training labels
+
+* **output:** (void)
+*  **example:**
+
+        // Create data for a 2-class classification problem
+        QList<Mat> images = QList<Mat>() << Template("training_pic1.jpg").m()
+                                         << Template("training_pic2.jpg").m()
+                                         << Template("training_pic3.jpg").m()
+                                         << Template("training_pic4.jpg").m();
+
+        QList<float> labels = QList<float>() << 0 << 0 << 1 << 1;
+
+        Classifier *classifier = Classifier::make("Classifier");
+        rep->train(images, labels);
+
+## float classify(const [Mat][Mat] &image) const {: #classify }
+
+This is a pure virtual function. Classify a provided input image.
+
+* **function description:**
+
+        virtual float classify(const Mat &image) const = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    image | const [Mat][Mat] & | Input image to be classified
+
+* **output:** (float) Returns the classification value of the image. The value can be a confidence, a regression, or a class. In 2-class classification is it often a confidence which has been normalized such that 0 is the inflection point. Values below zero represent a negative classification and values above represent a positive classification.
+* **example:**
+        Classifier *classifier = Classifier::make("2ClassClassifier"); // assume classifier is already trained
+
+        Template p1("pos_image1.jpg"); // positive sample
+        Template n1("neg_image1.jpg"); // negative sample
+
+        classifier->classify(p1); // returns confidence > 0
+        classifier->classify(n1); // returns confidence < 0
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+## [Classifier](classifier.md) \*make([QString][QString] str, [QObject][QObject] \*parent) {: #make }
+
+Make a [Classifier](classifier.md) from a string. The string is passed to [Factory](../factory/factory.md)::[make](../factory/statics.md#make) to be turned into a classifier.
+
+* **function definition:**
+
+        static Classifier *make(QString str, QObject *parent)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    str | [QString][QString] | String describing the classifier
+    parent | [QObject][QObject] \* | Parent of the object to be created
+
+* **output:** ([Classifier](classifier.md) \*) Returns a pointer to the [Classifier](classifier.md) described by the string
+* **see:** [Factory::make](../factory/statics.md#make)
+* **example:**
+
+        Classifier *classifier = Classifier::make("Classifier(representation=Representation(property1=value1)");
+        classifier->description(); // Returns "Classifier(representation=Representation(property1=value1))"
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+<!-- CompositeTransform -->
+
+Inherits [TimeVaryingTransform](../timevaryingtransform/timevaryingtransform.md)
+
+Base class for [Transforms](../transform/transform.md) that aggregate subtransforms.
+
+See:
+
+* [Properties](properties.md)
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Functions](functions.md)
+
+CompositeTransforms are the base class for [Transforms](../transform/transform.md) that have a list of child transforms. It is used internally for plugins like pipes and forks. It inherits from [TimeVaryingTransform](../timevaryingtransform/timevaryingtransform.md) so that it can properly handle having children (one or many) that are time varying.
+Constructor | Description
+--- | ---
+CompositeTransform() | Default constructor. Calls the [TimeVaryingTransform](../timevaryingtransform/timevaryingtransform.md) [constructor](../timevaryingtransform/constructors.md) with [independent](../transform/members.md#independent) set to false.
+## bool timeVarying() {: #timevarying }
+
+Check if the transform is time varying. The transform is time varying if any of its children are time varying.
+
+* **function definition:**
+
+		bool timeVarying() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns [isTimeVarying](members.md#istimevarying)
+
+## void init() {: #init }
+
+Initialize the transform. If any of the child transform are time varying, [isTimeVarying](members.md#istimevarying) is set to true. Similarly if any of the child transforms are trainable, [trainable](../transform/members.md#trainable) is set to true.
+
+* **function definition:**
+
+		void init()
+
+* **parameters:** NONE
+* **output:** (void)
+
+## void project(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #project-1 }
+
+If the transform is time varying call [timeInvariantAlias](../timevaryingtransform/members.md#timeinvariantalias) project, which ensures thread safety. If the transform is not time varying call [_project](#_project-1).
+
+* **function definition:**
+
+		virtual void project(const Template &src, Template &dst) const
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	src | const [Template](../template/template.md) & | The input template
+	dst | [Template](../template/template.md) & | The output template
+
+* **output:** (void)
+
+## void project(const [TemplateList](../templatelist/templatelist.md) &src, [TemplateList](../templatelist/templatelist.md) &dst) {: #project-2 }
+
+If the transform is time varying call [timeInvariantAlias](../timevaryingtransform/members.md#timeinvariantalias) project, which ensures thread safety. If the transform is not time varying call [_project](#_project-2).
+
+* **function definition:**
+
+		virtual void project(const TemplateList &src, TemplateList &dst) const
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	src | const [TemplateList](../templatelist/templatelist.md) & | The input template list
+	dst | [TemplateList ](../templatelist/templatelist.md) & | The output template list
+
+* **output:** (void)
+
+## void \_project(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #\_project-1 }
+
+This is a pure virtual function. It should handle standard projection through the child transforms
+
+* **function definition:**
+
+		virtual void _project(const Template &src, Template &dst) const = 0
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	src | const [Template](../template/template.md) & | The input template
+	dst | [Template](../template/template.md) & | The output template
+
+* **output:** (void)
+
+## void \_project(const [TemplateList](../templatelist/templatelist.md) &src, [TemplateList](../templatelist/templatelist.md) &dst) {: #\_project-2 }
+
+This is a pure virtual function. It should handle standard projection through the child transforms
+
+* **function definition:**
+
+		virtual void _project(const TemplateList &src, TemplateList &dst) const = 0
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	src | const [TemplateList](../templatelist/templatelist.md) & | The input template list
+	dst | [TemplateList](../templatelist/templatelist.md) & | The output template list
+
+* **output:** (void)
+
+## [Transform](../transform/transform.md) \*simplify(bool &newTransform) {: #simplify }
+
+This is a virtual function. Calls [simplify](../transform/functions.md#simplify) on each child transform.
+
+* **function definition:**
+
+		virtual Transform *simplify(bool &newTransform)
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	newTransform | bool & | True if a new, simplified, transform was allocated inside this call, false otherwise
+
+* **output:** ([Transform](../transform/transform.md) \*) Returns itself if none of the children can be simplified. newTransform is false in this case. If any child can be simplified a new [CompositeTransform](compositetransform.md) is allocated and its children are set as the result of calling simplify on each of the old children. newTransform is true in this case
+
+## [Transform](../transform/transform.md) \*smartCopy(bool &newTransform) {: #smartcopy }
+
+Get a smart copy, meaning a copy only if one is required, of this transform
+
+* **function definition:**
+
+		Transform *smartCopy(bool &newTransform)
+
+* **parameters:**
+
+	Parameter | Type | Description
+	--- | --- | ---
+	newTransform | bool & | True if a new, simplified, transform was allocated inside this call, false otherwise
+
+* **output:** ([Transform](../transform/transform.md) \*) Returns itself if [isTimeVarying](members.md#istimevarying) is false (no copy needed). newTransform is set to false in this case. If [isTimeVarying](members.md#istimevarying) is true, a new [CompositeTransform](compositetransform.md) is allocated and its children are set to the result of calling smartCopy on each of the old children. newTransform is true in this case.
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id="istimevarying"></a>isTimeVarying | bool | True if any child transform is time varying, false otherwise
+Property | Type | Description
+--- | --- | ---
+transforms | [QList][QList]&lt;[Transform](../transform/transform.md)\*&gt; | List of child transforms
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+<!-- CONTEXT -->
+
+The singleton class of global settings.
+
+See:
+
+* [Members](members.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+Before including and using OpenBR in a project the user must call [initialize](statics.md#initialize). Before the program terminates the user must call [finalize](statics.md#finalize). The settings are accessible as Context \*Globals.
+## bool contains(const [QString][QString] &name) {: #contains }
+
+Check if a property exists in the [global metadata](context.md).
+
+* **function definition:**
+
+        bool contains(const QString &name);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    name | const [QString][QString] & | [Metadata](context.md) key. It must be queryable using [QObject::property][QObject::property].
+
+* **output:** (bool) Returns true if the provided key is a global property.
+* **see:** [setProperty](#setproperty)
+* **example:**
+
+        Globals->contains("path"); // returns true
+        Globals->contains("key"); // returns false
+
+
+## void setProperty(const [QString][QString] &key, const [QString][QString] &value) {: #setproperty }
+
+Set a global property.
+
+* **function definition:**
+
+        void setProperty(const QString &key, const QString &value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | [Metadata](context.md) key
+    value | const [QString][QString] & | Value to be added to the [Metadata](context.md)
+
+* **output:** (void)
+* **see:** [contains](#contains)
+* **example:**
+
+        Globals->contains("key"); // returns false
+        Globals->setProperty("key", "value");
+        Globals->contains("key"); // returns true
+
+
+## void printStatus() {: #printstatus }
+
+Prints the current progress statistics to **stdout**.
+
+* **function definition:**
+
+void printStatus();
+
+* **parameters:** NONE
+* **output:** (void)
+* **see:** [progress](#progress)
+* **example:**
+
+        Globals->printStatus(); // returns 00.00%  ELAPSED=00:00:00  REMAINING=99:99:99  COUNT=0
+
+
+## int timeRemaining() const {: #timeremaining }
+
+Get the time remaining in seconds of a call to [Train](../apifunctions.md#train), [Enroll](../apifunctions.md#enroll-1) or [Compare](../apifunctions.md#compare).
+
+* **function defintion:**
+
+        int timeRemaining() const;
+
+* **parameters:** NONE
+* **output:** (int) Returns the estimated time remaining in the currently running process. If not process is running returns -1.
+
+## float progress() {: #progress }
+
+Get the completion percentage of a call to [Train](../apifunctions.md#train), [Enroll](../apifunctions.md#enroll-1) or [Compare](../apifunctions.md#compare).
+
+* **function definition:**
+
+        float progress() const;
+
+* **parameters:** NONE
+* **output:** (float) Returns the fraction of the currently running job that has been completed.
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QObject::property]: http://doc.qt.io/qt-5/qobject.html#property "QObject::property"
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=sdkpath></a>sdkPath | [QString][QString] | Path to the sdk. Path + **share/openbr/openbr.bib** must exist.
+<a class="table-anchor" id=algorithm></a>algorithm | [QString][QString] | The default algorithm to use when enrolling and comparing templates.
+<a class="table-anchor" id=log></a>log | [QString][QString] | Optional log file to copy **stderr** to.
+<a class="table-anchor" id=path></a>path | [QString][QString] | Path to use when resolving images specified with relative paths. Multiple paths can be specified using a semicolon separator.
+<a class="table-anchor" id=parallelism></a>parallelism | int | The number of threads to use. The default is the maximum of 1 and the value returned by ([QThread][QThread]::idealThreadCount() + 1).
+<a class="table-anchor" id=usegui></a>useGui | bool | Whether or not to use GUI functions. The default is true.
+<a class="table-anchor" id=blocksize></a>blockSize | int | The maximum number of templates to process in parallel. The default is: ```parallelism * ((sizeof(void*) == 4) ? 128 : 1024)```
+<a class="table-anchor" id=quiet></a>quiet | bool | If true, no messages will be sent to the terminal. The default is false.
+<a class="table-anchor" id=verbose></a>verbose | bool | If true, extra messages will be sent to the terminal. The default is false.
+<a class="table-anchor" id=mostrecentmessage></a>mostRecentMessage | [QString][QString] | The most recent message sent to the terminal.
+<a class="table-anchor" id=currentstep></a>currentStep | double | Used internally to compute [progress](functions.md#progress) and [timeRemaining](functions.md#timeremaining).
+<a class="table-anchor" id=totalsteps></a>totalSteps | double | Used internally to compute [progress](functions.md#progress) and [timeRemaining](functions.md#timeremaining).
+<a class="table-anchor" id=enrollall></a>enrollAll | bool | If true, enroll 0 or more templates per image. Otherwise, enroll exactly one. The default is false.
+<a class="table-anchor" id=filters></a>filters | Filters | Filters is a ```typedef QHash<QString,QStringList> Filters```. Filters that automatically determine imposter matches based on target ([gallery](../gallery/gallery.md)) template metadata. See [FilterDistance](../../../plugin_docs/distance.md#filterdistance).
+<a class="table-anchor" id=buffer></a>buffer | [QByteArray][QByteArray] | File output is redirected here if the file's basename is "buffer". This clears previous contents.
+<a class="table-anchor" id=scorenormalization></a>scoreNormalization | bool | If true, enable score normalization. Otherwise disable it. The default is true.
+<a class="table-anchor" id=crossvalidate></a>crossValidate | int | Perform k-fold cross validation where k is the value of **crossValidate**. The default value is 0.
+<a class="table-anchor" id=modelsearch></a>modelSearch | [QList][QList]&lt;[QString][QString]&gt; | List of paths to search for sub-models on.
+<a class="table-anchor" id=abbreviations></a>abbreviations | [QHash][QHash]&lt;[QString][QString], [QString][QString]&gt; | Used by [Transform](../transform/transform.md)::[make](../transform/statics.md#make) to expand abbreviated algorithms into their complete definitions.
+<a class="table-anchor" id=starttime></a>startTime | [QTime][QTime] | Used to estimate [timeRemaining](functions.md#timeremaining).
+<a class="table-anchor" id=logfile></a>logFile | [QFile][QFile] | Log file to write to.
+
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QHash]: http://doc.qt.io/qt-5/qhash.html "QHash"
+[QThread]: http://doc.qt.io/qt-5/qthread.html "QThread"
+[QByteArray]: http://doc.qt.io/qt-5/qbytearray.html "QByteArray"
+[QTime]: http://doc.qt.io/qt-5/QTime.html "QTime"
+[QFile]: http://doc.qt.io/qt-5/qfile.html "QFile"
+## void initialize(int &argc, char \*argv[], [QString][QString] sdkPath = "", bool useGui = true) {: #initialize }
+
+Call *once* at the start of the application to allocate global variables. If the project is a [Qt][Qt] project this call should occur after initializing <tt>QApplication</tt>.
+
+* **function definition:**
+
+        static void initialize(int &argc, char *argv[], QString sdkPath = "", bool useGui = true);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    argc | int & | Number of command line arguments as provided by <tt>main()</tt>
+    argv | char * [] | Command line arguments as provided by <tt>main()</tt>
+    sdkPath | [QString][QString] | (Optional) The path to the folder containing **share/openbr/openbr.bib**. If no path is provided (default) OpenBR automatically searches: <ul> <li>The working directory</li> <li>The executable's location</li> </ul>
+    useGui | bool | (Optional) Make OpenBR as a [QApplication][QApplication] instead of a [QCoreApplication][QCoreApplication]. Default is true.
+
+* **output:** (void)
+* **see:** [finalize](#finalize)
+* **example:**
+
+        int main(int argc, char \*argv[])
+        {
+            QApplication(argc, argv); // ONLY FOR QT PROJECTS
+            br::Context::initialize(argc, argv);
+
+            // ...
+
+            br::Context::finalize();
+            return 0;
+        }
+
+## void finalize() {: #finalize }
+
+Call *once* at the end of the application to deallocate global variables.
+
+* **function definition:**
+
+        static void finalize();
+
+* **parameters:** NONE
+* **output:** (void)
+* **see:** [initialize](#initialize)
+
+
+## bool checkSDKPath(const [QString][QString] &sdkPath) {: #checksdkpath }
+
+Check if a given SDK path is valid. A valid SDK satisfies
+
+    exists(sdkPath + "share/openbr/openbr.bib")
+
+* **function definition:**
+
+        static bool checkSDKPath(const QString &sdkPath);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    sdkPath | const [QString][QString] & | Possible sdk path to examine
+
+* **output:** (bool) Returns true if the sdkPath + "share/openbr/openbr.bib" exists, otherwise returns false.
+* **example:**
+
+        // OpenBR is at /libs/openbr
+
+        checkSDKPath("/libs/openbr/"); // returns true
+        checkSDKPath("/libs/"); // returns false
+
+## [QString][QString] about() {: #about }
+
+Get a string with the name, version, and copyright of the project. This string is suitable for printing or terminal.
+
+* **function definition:**
+
+        static QString about();
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a string containing the name, version and copyright of the project
+* **example:**
+
+        // Using OpenBR version 0.6.0
+        Context::about(); // returns "OpenBR 0.6.0 Copyright (c) 2013 OpenBiometrics. All rights reserved."
+
+## [QString][QString] version() {: #version }
+
+Get the version of the SDK.
+
+* **function definition:**
+
+        static QString version();
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a string containing the version of the OpenBR SDK. The string has the format *<MajorVersion\>*\.*<MinorVersion\>*\.*<PatchVersion\>*
+* **example:**
+
+        // Using OpenBR version 0.6.0
+        Context::version(); // returns "0.6.0"
+
+## [QString][QString] scratchPath() {: #scratchpath }
+
+Get the scratch directory used by OpenBR. This directory should be used as the root directory for managing temporary files and providing process persistence.
+
+* **function definition:**
+
+        static QString scratchPath();
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a string pointing to the OpenBR scratch directory. The string has the format *<path/to/user/home\><OpenBR-\><MajorVersion\>*\.*<MinorVersion\>*.
+* **see:** [version](#version)
+* **example:**
+
+        // Using OpenBR version 0.6.0
+        Context::scratchPath(); // returns "/path/to/user/home/OpenBR-0.6"
+
+## [QStringList][QStringList] objects(const char \*abstractions = ".\*", const char \*implementations = ".\*", bool parameters = true) {: #objects }
+
+Get a collection of objects in OpenBR that match provided regular expressions. This function uses [QRegExp][QRegExp] syntax.
+
+* **function definition:**
+
+        static QStringList objects(const char *abstractions = ".*", const char *implementations = ".*", bool parameters = true)
+
+* **parameters:**
+
+        Parameter | Type | Description
+        --- | --- | ---
+        abstractions | const char \* | (Optional) Regular expression of the abstractions to search. Default is ".\*"
+        implementations | const char \* | (Optional) Regular expression of the implementations to search. Default is ".\*".
+        parameters | bool | (Optional) If true include parameters after object name. Default is true.
+
+* **output:** ([QStringList][QStringList]) Return names and parameters for the requested objects. Each object is newline separated. Arguments are separated from the object name with tabs.
+* **example:**
+
+        // Find all 'Rnd' Transforms
+        Context::objects("Transform", "Rnd.*", false); // returns ["RndPoint", "RndRegion", "RndRotate", "RndSample", "RndSubspace"]
+
+<!-- Links -->
+[Qt]: http://qt-project.org/ "Qt"
+[QApplication]: http://doc.qt.io/qt-5/qapplication.html "QApplication"
+[QCoreApplication]: http://doc.qt.io/qt-5/qcoreapplication.html "QCoreApplication"
+
+[QRegExp]: http://doc.qt.io/qt-5/QRegExp.html "QRegExp"
+
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+Constructor / Destructor | Description
+--- | ---
+virtual ~Distance() | The default destructor. It doesn't do anything.
+Inherits [Object](../object/object.md)
+
+Plugin base class for comparing two [Templates](../template/template.md)
+
+See:
+
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+Distances are used to find the *distance* or *similarity* between two feature vectors. A *distance* is defined such that a higher value indicates a larger difference between templates. A *similarity* is the opposite, higher values indicate a smaller difference between templates (they are more similar).
+
+## bool trainable() {: #trainable }
+
+This is a virtual function. Check if the distance is trainable. The default version returns true. Distances that are not trainable should derive from [UntrainableDistance](../untrainabledistance/untrainabledistance.md) instead.
+
+* **function defintion:**
+
+        virtual bool trainable()
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if the distance is trainable, false otherwise.
+
+## void train(const [TemplateList](../templatelist/templatelist.md) &src) {: #train }
+
+This is a pure virtual function. Train the distance on a provided [TemplateList](../templatelist/templatelist.md) of data. The structure of the data is dependent on the distance to be trained. Distances that are not trainable should derive from [UntrainableDistance](../untrainabledistance/untrainabledistance.md) so they do not have to overload this function.
+
+* **function definition:**
+
+        virtual void train(const TemplateList &src) = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [TemplateList](../templatelist/templatelist.md) & | Training data for the distance.
+
+* **output:** (void)
+* **example:**
+
+        // Create data for a 2-class classification problem
+        Template t1("training_pic1.jpg");
+        t1.file.set("Label", 0);
+        Template t2("training_pic2.jpg");
+        t2.file.set("Label", 0);
+        Template t3("training_pic3.jpg");
+        t3.file.set("Label", 1);
+        Template t4("training_pic4.jpg");
+        t4.file.set("Label", 1);
+
+        TemplateList training_data(QList<Template>() << t1 << t2 << t3 << t4);
+
+        Transform *distance = Distance::fromAlgorithm("Enrollment:Distance");
+        distance->train(training_data); // Images are enrolled through Enrollment and the passed to Distance for training
+
+
+## void compare(const [TemplateList](../templatelist/templatelist.md) &target, const [TemplateList] &query, [Output](../output/output.md)) {: #compare-1 }
+
+This is a virtual function. Compare two [TemplateLists](../templatelist/templatelist.md) and store the results in a provided output.
+
+* **function definition:**
+
+        virtual void compare(const TemplateList &target, const TemplateList &query, Output *output) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    target | const [TemplateList](../templatelist/templatelist.md) & | List of templates to compare the query against
+    query | const [TemplateList](../templatelist/templatelist.md) & | List of templates to compare against the target
+    output | [Output](../output/output.md) \* | [Output](../output/output.md) plugin to use to store the results of the comparisons
+
+* **output:** (void)
+
+
+## [QList][QList]&lt;float&gt; compare(const [TemplateList](../templatelist/templatelist.md) &target, const [Template](../template/template.md) &query) {: #compare-2 }
+
+This is a virtual function. Compare a query against a list of targets. Each comparison results in a floating point response which is the distance between the query and a specific target.
+
+* **function definition:**
+
+        virtual QList<float> compare(const TemplateList &targets, const Template &query) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targets | const [TemplateList](../templatelist/templatelist.md) & | List of templates to compare the query against
+    query | const [Template](../template/template.md) & | Query template to be compared
+
+* **output:** ([QList][QList]&lt;float&gt;) Returns a list of the responses from each comparison between the query and a target.
+* **example:**
+
+        Template t1("target_picture1.jpg");
+        Template t2("target_picture2.jpg");
+        Template t3("target_picture3.jpg");
+
+        TemplateList targets = TemplateList() << t1 << t2 << t3;
+
+        Template query("query_picture.jpg");
+
+        algorithm = "Enrollment:Distance";
+
+        Transform *transform = Transform::fromAlgorithm(algorithm);
+        Distance *distance = Distance::fromAlgorithm(algorithm);
+
+        targets >> *transform;
+        query   >> *transform;
+
+        distance->compare(targets, query); // returns [0.37, -0.56, 4.35] *Note results are made up!
+
+
+## float compare(const [Template](../template/template.md) &a, const [Template](../template/template.md) &b) {: #compare-3}
+
+This is a virtual function. Compare two templates and get the difference between them.
+
+* **function definition:**
+
+        virtual float compare(const Template &a, const Template &b) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    a | const [Template](../template/template.md) & | First template to compare
+    b | const [Template](../template/template.md) & | Second template to compare
+
+* **output:** (float) Returns the calculated difference between the provided templates
+* **example:**
+
+Template a("picture_a.jpg");
+Template b("picture_b.jpg");
+
+algorithm = "Enrollment:Distance";
+
+Transform *transform = Transform::fromAlgorithm(algorithm);
+Distance *distance = Distance::fromAlgorithm(algorithm);
+
+a >> *transform;
+b >> *transform;
+
+distance->compare(a, b); // returns 16.43 *Note results are made up!
+
+
+## float compare(const [Mat][Mat] &a, const [Mat][Mat] &b) {: #compare-4}
+
+This is a virtual function. Compare two [Mats][Mat] and get the difference between them.
+
+* **function definition:**
+
+        virtual float compare(const Mat &a, const Mat &b) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    a | const [Mat][Mat] & | First matrix to compare
+    b | const [Mat][Mat] & | Second matrix to compare
+
+* **output:** (float) Returns the calculated difference between the provided [Mats][Mat]
+* **example:**
+
+        Template a("picture_a.jpg");
+        Template b("picture_b.jpg");
+
+        algorithm = "Enrollment:Distance";
+
+        Transform *transform = Transform::fromAlgorithm(algorithm);
+        Distance *distance = Distance::fromAlgorithm(algorithm);
+
+        a >> *transform;
+        b >> *transform;
+
+        distance->compare(a.m(), b.m()); // returns 16.43 *Note results are made up!
+
+
+## float compare(const uchar \*a, const uchar \*b, size_t size) {: #compare-5 }
+
+This is a virtual function. Compare two buffers and get the difference between them
+
+* **function definition:**
+
+        virtual float compare(const uchar *a, const uchar *b, size_t size) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    a | const uchar \* | First buffer to compare
+    b | const uchar \* | Second buffer to compare
+    size | size_t | Size of buffers a and b (they must be the same size)
+
+* **output:** (float) Returns the calculated difference between the provided buffers
+* **example:**
+
+        Template a("picture_a.jpg");
+        Template b("picture_b.jpg");
+
+        algorithm = "Enrollment:Distance";
+
+        Transform *transform = Transform::fromAlgorithm(algorithm);
+        Distance *distance = Distance::fromAlgorithm(algorithm);
+
+        a >> *transform;
+        b >> *transform;
+
+        distance->compare(a.m().ptr(), b.m().ptr()); // returns -4.32 *Note results are made up!
+
+
+## [Distance](distance.md) \*make(const [QString][QString] &description) {: #make }
+
+This is a protected function. Makes a child distance from a provided description by calling [make](statics.md#make) with parent = <tt>this</tt>.
+
+* **function definition:**
+
+        inline Distance *make(const QString &description)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    description | const [QString][QString] & | Description of the child distance
+
+* **output:** ([Distance](distance.md) \*) Returns a pointer to the created child distance
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+## [Distance](distance.md) \*make([QString][QString] str, [QObject][QObject] \*parent) {: #make }
+
+Make a [Distance](distance.md) from a string. This function converts the abbreviation character **+** into it's full-length alternative.
+
+Abbreviation | Translation
+--- | ---
+\+ | [PipeDistance](../../../plugin_docs/distance.md#pipedistance). Each [Distance](distance.md) linked by a **+** is turned into a child of a single [PipeDistance](../../../plugin_docs/distance.md#pipedistance). "Distance1+Distance2" becomes "Pipe([Distance1,Distance2])". [Templates](../template/template.md) are projected through the children of a pipe in series, the output of one become the input of the next.
+
+The expanded string is then passed to [Factory](../factory/factory.md)::[make](../factory/statics.md#make) to be turned into a distance.
+
+* **function definition:**
+
+        static Distance *make(QString str, QObject *parent)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    str | [QString][QString] | String describing the distance
+    parent | [QObject][QObject] \* | Parent of the object to be created
+
+* **output:** ([Distance](distance.md) \*) Returns a pointer to the [Distance](distance.md) described by the string
+* **see:** [Factory::make](../factory/statics.md#make)
+* **example:**
+
+        Distance::make("Distance1+Distance2+Distance3")->description(); // returns "Pipe(distances=[Distance1,Distance2,Distance3])".
+
+## [QSharedPointer][QSharedPointer]&lt;[Distance](distance.md)&gt; fromAlgorithm(const [QString][QString] &algorithm) {: #fromalgorithm }
+
+Create a [Distance](distance.md) from an OpenBR algorithm string. The [Distance](distance.md) is created using everything to the right of a **:** or a **!** in the string.
+
+* **function definition:**
+
+        static QSharedPointer<Distance> fromAlgorithm(const QString &algorithm)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    algorithm | const [QString][QString] & | Algorithm string to construct the [Distance](distance.md) from
+
+* **output:** ([QSharedPointer][QSharedPointer]&lt;[Distance](distance.md)&gt;) Returns a pointer to the [Distance](distance.md) described by the algorithm.
+* **example:**
+
+    Distance::fromAlgorithm("EnrollmentTransform:Distance")->decription(); // returns "Distance"
+    Distance::fromAlgorithm("EnrollmentTransform!Distance1+Distance2")->decription(); // returns "Pipe(distances=[Distance1,Distance2])
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+[QSharedPointer]: http://doc.qt.io/qt-5/qsharedpointer.html "QSharedPointer"
+Constructor \| Destructor | Description
+--- | ---
+Factory([QString][QString] name) | This is a special constructor in OpenBR. It is used to register new objects in the [registry](members.md#registry).
+virtual ~Factory() | Default destructor
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+<!-- FACTORY -->
+
+For the run time construction of objects from strings.
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Macros](macros.md)
+* [Static Functions](statics.md)
+
+Uses the Industrial Strength Pluggable Factory model described [here](http://adtmag.com/articles/2000/09/25/industrial-strength-pluggable-factories.aspx).
+
+OpenBR's plugin architecture is premised on the idea that algorithms can be described as strings and can be built at runtime. Constructing plugins from strings is the job of the [Factory](factory.md). For a plugin to be built by the [Factory](factory.md) it must inherit from [Object](../object/object.md). It also must be registered with the factory at compile time using [BR_REGISTER](macros.md#br_register). At runtime, the [Factory](factory.md) will look up provided strings in its [registry](members.md#registry) and, if they exist, return the described plugins.
+## BR_REGISTER {: #br_register }
+
+A special macro to register plugins in the [Factory](factory.md)::[registry](members.md#registry). When a plugin is registered the associated abstraction type will be removed from it's name, if it exists. For example, ```BR_REGISTER(Transform, ExampleTransform)``` will be registered as "Example". Plugins *do not* have to have the abstraction as part of their name.
+
+* **macro definition:**
+
+        #define BR_REGISTER(ABSTRACTION,IMPLEMENTATION)  
+
+* **parameters:**
+
+    Parameter | Description
+    --- | ---
+    ABSTRACTION | The Abstraction that the object inherits from. The object must inherit from [Object](../object/object.md) somewhere in its inheritance tree. Abstractions should also implement ```ABSTRACTION *make()```. See [Transform](../transform/transform.md) as an example of an abstraction.
+    IMPLEMENTATION | The Implementation of the object. This is the definition of the object you want returned when you call ```Factory<T>::make```.
+
+* **example:**
+
+        class Implementation : public Abstraction
+        {
+            Q_OBJECT
+
+            ... // some functions etc.
+        };
+
+        BR_REGISTER(Abstraction, Implementation)
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=registry></a>registry | static [QMap][QMap]&lt;[QString][QString],[Factory](factory.md)&lt;<tt>T</tt>&gt;\*&gt; | List of all objects that have been registered with the factory. Registered objects are stored in this static registry by abstraction type.
+
+<!-- Links -->
+[QMap]: http://doc.qt.io/qt-5/qmap.html "QMap"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+## <tt>T</tt> \*make(const [File](../file/file.md) &file) {: #make }
+
+This function constructs a plugin of type <tt>T</tt> from a provided [File](../file/file.md). The [File](../file/file.md) [name](../file/members.md#name) must already be in the [registry](members.md#registry) to be made.
+
+* **function definition:**
+
+        static T *make(const File &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    file | const [File](../file/file.md) & | File describing the object to be constructed
+
+* **output:** (<tt>T</tt>) Returns an object of type <tt>T</tt>. <tt>T</tt> must inherit from [Object](../object/object.md).
+* **example:**
+
+        Transform *transform = Factory<Transform>::make("ExampleTransform(Property1=Value1,Property2=Value2)");
+        // returns a pointer to an instance of ExampleTransform with property1 set to value1
+        // and property2 set to value 2.
+
+## [QList][QList]&lt;[QSharedPointer][QSharedPointer]&lt;<tt>T</tt>&gt;&gt;makeAll {: #makeall }
+
+Make all of the registered plugins for a specific abstraction.
+
+* **function definition:**
+
+        static QList< QSharedPointer<T> > makeAll()
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QSharedPointer][QSharedPointer]&lt;<tt>T</tt>&gt;&gt;) Returns a list of all of the objects registered to a particular abstraction <tt>T</tt>
+* **example:**
+
+        BR_REGISTER(Transform, FirstTransform)
+        BR_REGISTER(Transform, SecondTransform)
+
+        QList<QSharedPointer<Transform> > = Factory<Transform>::makeAll(); // returns a list with pointers to FirstTransform and SecondTransform
+
+
+## [QStringList][QStringList] names() {: #names }
+
+Get the names of all of the registered objects for a specific abstraction.
+
+* **function definition:**
+
+        static QStringList names()
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns a list of object names from the [registry](members.md#registry)
+* **example:**
+
+        BR_REGISTER(Transform, FirstTransform)
+        BR_REGISTER(Transform, SecondTransform)
+
+        QStringList names = Factory<Transform>::names(); // returns ["First", "Second"]
+
+
+## [QString][QString] parameters(const [QString][QString] &name) {: #parameters }
+
+Get the parameters for the plugin defined by the provided name.
+
+* **function definition:**
+
+        static QString parameters(const QString &name)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    name | const [QString][QString] & | Name of a plugin
+
+* **output:** ([QString][QString]) Returns a string with each property and its value seperated by commas.
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1)
+            BR_PROPERTY(float, property2, 2.5)
+            BR_PROPERTY(QString, property3, "Value")
+
+            ...
+        };
+
+        Factory<Transform>::parameters("Example"); // returns "int property1 = 1, float property2 = 2.5, QString property3 = Value"
+        Factory<Transform>::parameters("Example(property3=NewValue)"); // returns "int property1 = 1, float property2 = 2.5, QString property3 = NewValue"
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QSharedPointer]: http://doc.qt.io/qt-5/qsharedpointer.html "QSharedPointer"
+Constructor | Description
+--- | ---
+File() | Default constructor. Sets [name](members.md#name) to false.
+File(const [QString][QString] &file) | Initializes the file by calling the private function init.
+File(const [QString][QString] &file, const [QVariant][QVariant] &label) | Initializes the file by calling the private function init. Append label to the [metadata](members.md#m_metadata) using the key "Label".
+File(const char \*file) | Initializes the file with a c-style string.
+File(const [QVariantMap][QVariantMap] &metadata) | Sets [name](members.md#name) to false and sets the [file metadata](members.md#m_metadata) to metadata.
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[QVariantMap]: http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef "QVariantMap"
+A file path with associated metadata.
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+The File is one of two important data structures in OpenBR (the [Template](../template/template.md) is the other).
+It is typically used to store the path to a file on disk with associated metadata.
+The ability to associate a key/value metadata table with the file helps keep the API simple while providing customizable behavior.
+
+When querying the value of a metadata key, the value will first try to be resolved against the file's private metadata table.
+If the key does not exist in its local table then it will be resolved against the properties in the global Context.
+By design file metadata may be set globally using Context::setProperty to operate on all files.
+
+Files have a simple grammar that allow them to be converted to and from strings.
+If a string ends with a **]** or **)** then the text within the final **[]** or **()** are parsed as comma separated metadata fields.
+By convention, fields within **[]** are expected to have the format <tt>[key1=value1, key2=value2, ..., keyN=valueN]</tt> where order is irrelevant.
+Fields within **()** are expected to have the format <tt>(value1, value2, ..., valueN)</tt> where order matters and the key context dependent.
+The left hand side of the string not parsed in a manner described above is assigned to [name](members.md#name).
+
+Values are not necessarily stored as strings in the metadata table.
+The system will attempt to infer and convert them to their "native" type.
+The conversion logic is as follows:
+
+1. If the value starts with **[** and ends with **]** then it is treated as a comma separated list and represented with [QVariantList][QVariantList]. Each value in the list is parsed recursively.
+2. If the value starts with **(** and ends with **)** and contains four comma separated elements, each convertable to a floating point number, then it is represented with [QRectF][QRectF].
+3. If the value starts with **(** and ends with **)** and contains two comma separated elements, each convertable to a floating point number, then it is represented with [QPointF][QPointF].
+4. If the value is convertable to a floating point number then it is represented with <tt>float</tt>.
+5. Otherwise, it is represented with [QString][QString].
+
+Metadata keys fall into one of two categories:
+* camelCaseKeys are inputs that specify how to process the file.
+* Capitalized_Underscored_Keys are outputs computed from processing the file.
+
+Below are some of the most commonly occurring standardized keys:
+
+Key             | Value          | Description
+---             | ----           | -----------
+name            | QString        | Contents of [name](members.md#name)
+separator       | QString        | Separate [name](members.md#name) into multiple files
+Index           | int            | Index of a template in a template list
+Confidence      | float          | Classification/Regression quality
+FTE             | bool           | Failure to enroll
+FTO             | bool           | Failure to open
+\*_X             | float          | Position
+\*_Y             | float          | Position
+\*_Width         | float          | Size
+\*_Height        | float          | Size
+\*_Radius        | float          | Size
+Label           | QString        | Class label
+Theta           | float          | Pose
+Roll            | float          | Pose
+Pitch           | float          | Pose
+Yaw             | float          | Pose
+Points          | QList&lt;QPointF&gt; | List of unnamed points
+Rects           | QList&lt;Rect&gt;    | List of unnamed rects
+Age             | float          | Age used for demographic filtering
+Gender          | QString        | Subject gender
+Train           | bool           | The data is for training, as opposed to enrollment
+_\*              | \*              | Reserved for internal use
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QVariantList]: http://doc.qt.io/qt-5/qvariant.html#QVariantList-typedef "QVariantList"
+[QRectF]: http://doc.qt.io/qt-5/qrectf.html "QRectF"
+[QPointF]: http://doc.qt.io/qt-5/qpointf.html "QPointF"
+## operator [QString][QString]() {: #operator-qstring }
+
+Convenience function that allows [Files](file.md) to be used as [QStrings][QString]
+
+* **function definition:**
+
+        inline operator QString() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) returns [name](members.md#name).
+
+## [QString][QString] flat() {: #flat }
+
+Function to output files in string formats.
+
+* **function definition:**
+
+        QString flat() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) returns the [file name](members.md#name) and [metadata](members.md#m_metadata) as a formated string. The format is *filename*[*key1=value1,key2=value2,...keyN=valueN*].
+* **example:**
+
+        File file("picture.jpg");
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
+
+        file.flat(); // returns "picture.jpg[Key1=1,Key2=2]"
+
+
+## [QString][QString] hash() {: #hash }
+
+Function to output a hash of the file.
+
+* **function definition:**
+
+        QString hash() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns a hash of the file.
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
+
+        file.hash(); // returns "kElVwY"
+
+
+## [QStringList][QStringList] localKeys() {: #localkeys }
+
+Function to get the private [metadata](members.md#m_metadata) keys.
+
+* **function definition:**
+
+        inline QStringList localKeys() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns a list of the local [metadata](members.md#m_metadata) keys. They are called local because they do not include the keys in the [global metadata](../context/context.md).
+* **example:**
+
+    File file("../path/to/pictures/picture.jpg");
+    file.set("Key1", QVariant::fromValue<float>(1));
+    file.set("Key2", QVariant::fromValue<float>(2));
+
+    file.localKeys(); // returns [Key1, Key2]
+
+
+## [QVariantMap][QVariantMap] localMetadata() {: #localmetadata }
+
+Function to get the private [metadata](members.md#m_metadata).
+
+* **function definition:**
+
+        inline QVariantMap localMetadata() const
+
+* **parameters:** NONE
+* **output:** ([QVariantMap][QVariantMap]) Returns the local [metadata](members.md#m_metadata).
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
+
+        file.localMetadata(); // return QMap(("Key1", QVariant(float, 1)) ("Key2", QVariant(float, 2)))
+
+
+## void append(const [QVariantMap][QVariantMap] &localMetadata) {: #append-1 }
+
+Add new metadata fields to [metadata](members.md#m_metadata).
+
+* **function definition:**
+
+        void append(const QVariantMap &localMetadata)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    localMetadata | const [QVariantMap][QVariantMap] & | metadata to append to the local [metadata](members.md#m_metadata)
+
+* **output:** (void)
+* **example:**
+
+        File f();
+        f.set("Key1", QVariant::fromValue<float>(1));
+
+        QVariantMap map;
+        map.insert("Key2", QVariant::fromValue<float>(2));
+        map.insert("Key3", QVariant::fromValue<float>(3));
+
+        f.append(map);
+        f.flat(); // returns "[Key1=1, Key2=2, Key3=3]"
+
+
+## void append(const [File](file.md) &other) {: #append-2 }
+
+Append another file using the **;** separator. The [File](file.md) [names](members.md#name) are combined with the separator in between them. The [metadata](members.md#m_metadata) fields are combined. An additional field describing the separator is appended to the [metadata](members.md#m_metadata).
+
+* **function definition:**
+
+        void append(const File &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to append
+
+* **output:** (void)
+* **example:**
+
+        File f1("../path/to/pictures/picture1.jpg");
+        f1.set("Key1", QVariant::fromValue<float>(1));
+
+        File f2("../path/to/pictures/picture2.jpg");
+        f2.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key3", QVariant::fromValue<float>(3));
+
+        f1.append(f2);
+        f1.name; // return "../path/to/pictures/picture1.jpg;../path/to/pictures/picture2.jpg"
+        f1.localKeys(); // returns "[Key1, Key2, Key3, separator]"
+
+
+## [File](file.md) &operator+=(const [QMap][QMap]&lt;[QString][QString], [QVariant][QVariant]&gt; &other) {: #operator-pe-1 }
+
+Shortcut operator to call [append](#append-1).
+
+* **function definition:**
+
+        inline File &operator+=(const QMap<QString, QVariant> &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    other | const [QMap][QMap]&lt;[QString][QString], [QVariant][QVariant]&gt; & | Metadata map to append to the local [metadata](members.md#m_metadata)
+
+* **output:** ([File](file.md) &) Returns a reference to this file after the append occurs.
+* **example:**
+
+        File f();
+        f.set("Key1", QVariant::fromValue<float>(1));
+
+        QMap<QString, QVariant> map;
+        map.insert("Key2", QVariant::fromValue<float>(2));
+        map.insert("Key3", QVariant::fromValue<float>(3));
+
+        f += map;
+        f.flat(); // returns "[Key1=1, Key2=2, Key3=3]"
+
+
+## [File](file.md) &operator+=(const [File](file.md) &other) {: #operator-pe-2 }
+
+Shortcut operator to call [append](#append-2).
+
+* **function definition:**
+
+        inline File &operator+=(const File &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    other | const [File](file.md) & | File to append
+
+* **output:** ([File](file.md) &) Returns a reference to this file after the append occurs.
+* **example:**
+
+        File f1("../path/to/pictures/picture1.jpg");
+        f1.set("Key1", QVariant::fromValue<float>(1));
+
+        File f2("../path/to/pictures/picture2.jpg");
+        f2.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key3", QVariant::fromValue<float>(3));
+
+        f1 += f2;
+        f1.name; // return "../path/to/pictures/picture1.jpg;../path/to/pictures/picture2.jpg"
+        f1.localKeys(); // returns "[Key1, Key2, Key3, separator]"
+
+
+## [QList][QList]&lt;[File](file.md)&gt; split() {: #split-1 }
+
+This function splits the [File](file.md) into multiple files and returns them as a list. This is done by parsing the file [name](members.md#name) and splitting on the separator located at [metadata](members.md#m_metadata)["separator"]. If "separator" is not a [metadata](members.md#m_metadata) key, the returned list has the original file as the only entry. Each new file has the same [metadata](members.md#m_metadata) as the original, pre-split, file.
+
+* **function definition:**
+
+        QList<File> split() const
+
+* **parameters:** None
+* **output:** ([QList][QList]&lt;[File](file.md)&gt;) List of split files
+* **example:**
+
+        File f1("../path/to/pictures/picture1.jpg");
+        f1.set("Key1", QVariant::fromValue<float>(1));
+
+        f1.split(); // returns [../path/to/pictures/picture1.jpg[Key1=1]]
+
+        File f2("../path/to/pictures/picture2.jpg");
+        f2.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key3", QVariant::fromValue<float>(3));
+
+        f1.append(f2);
+        f1.split(); // returns [../path/to/pictures/picture1.jpg[Key1=1, Key2=2, Key3=3, separator=;],
+                    //          ../path/to/pictures/picture2.jpg[Key1=1, Key2=2, Key3=3, separator=;]]
+
+
+## [QList][QList]&lt;[File](file.md)&gt; split(const [QString][QString] &separator) {: #split-2 }
+
+This function splits the file into multiple files and returns them as a list. This is done by parsing the file [name](members.md#name) and splitting on the given separator. Each new file has the same [metadata](members.md#m_metadata) as the original, pre-split, file.
+
+* **function definition:**
+
+        QList<File> split(const QString &separator) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    separator | const [QString][QString] & | Separator to split the file name on
+
+* **output:** ([QList][QList]&lt;[File](file.md)&gt;) List of split files
+* **example:**
+
+        File f("../path/to/pictures/picture1.jpg,../path/to/pictures/picture2.jpg");
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.set("Key2", QVariant::fromValue<float>(2));
+
+        f.split(","); // returns [../path/to/pictures/picture1.jpg[Key1=1, Key2=2],
+                                  ../path/to/pictures/picture2.jpg[Key1=1, Key2=2]]
+
+
+## void setParameter(int index, const [QVariant][QVariant] &value) {: #setparameter }
+
+Insert a keyless value into the [metadata](members.md#m_metadata). Generic key of "ArgN" is used, where N is given as a parameter.
+
+* **function definition:**
+
+        inline void setParameter(int index, const QVariant &value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Number to append to generic key
+    value | const [QVariant][QVariant] & | Value to add to the metadata
+
+* **output:** (void)
+* **see:** [containsParameter](#containsparameter), [getParameter](#getparameter)
+* **example:**
+
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.set("Key2", QVariant::fromValue<float>(2));
+
+        f.setParameter(1, QVariant::fromValue<float>(3));
+        f.setParameter(5, QVariant::fromValue<float>(4));
+
+        f.flat(); // returns "[Key1=1, Key2=2, Arg1=3, Arg5=4]"
+
+
+## bool containsParameter(int index) {: #containsparameter }
+
+Check if the local [metadata](members.md#m_metadata) contains a keyless value.
+
+* **function definition:**
+
+        inline bool containsParameter(int index) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Index of the keyless value to check for
+
+* **output:** (bool) Returns true if the local [metadata](members.md#m_metadata) contains the keyless value, otherwise reutrns false.
+* **see:** [setParameter](#setparameter), [getParameter](#getparameter)
+* **example:**
+
+        File f;
+        f.setParameter(1, QVariant::fromValue<float>(1));
+        f.setParameter(2, QVariant::fromValue<float>(2));
+
+        f.containsParameter(1); // returns true
+        f.containsParameter(2); // returns true
+        f.containsParameter(3); // returns false
+
+
+## [QVariant][QVariant] getParameter(int index) {: #getparameter }
+
+Get a keyless value from the local [metadata](members.md#m_metadata). If the value does not exist an error is thrown.
+
+* **function definition:**
+
+        inline QVariant getParameter(int index) const
+
+* **parameter:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Index of the keyless value to look up. If the index does not exist an error is thrown.
+
+* **output:** ([QVariant][QVariant]) Returns the keyless value associated with the given index
+* **see:** [setParameter](#setparameter), [containsParameter](#containsparameter)
+* **example:**
+
+        File f;
+        f.setParameter(1, QVariant::fromValue<float>(1));
+        f.setParameter(2, QVariant::fromValue<float>(2));
+
+        f.getParameter(1); // returns 1
+        f.getParameter(2); // returns 2
+        f.getParameter(3); // error: index does not exist
+
+
+## bool operator==(const char \*other) {: #operator-ee-1 }
+
+Compare [name](members.md#name) against a c-style string.
+
+* **function definition:**
+
+        inline bool operator==(const char *other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const char \* | C-style string to compare against
+
+* **output:** (bool) Returns true if the strings are equal, false otherwise.
+* **example:**
+
+        File f("picture.jpg");
+
+        f == "picture.jpg";       // returns true
+        f == "other_picture.jpg"; // returns false
+
+
+## bool operator==(const [File](file.md) &other) {: #operator-ee-2 }
+
+Compare [name](members.md#name) and [metadata](members.md#m_metadata) against another file name and metadata.
+
+* **function definition:**
+
+        inline bool operator==(const File &other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to compare against
+
+* **output:** (bool) Returns true if the names and metadata are equal, false otherwise.
+* **example:**
+
+        File f1("picture1.jpg");
+        File f2("picture1.jpg");
+
+        f1 == f2; // returns true
+
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f2.set("Key2", QVariant::fromValue<float>(2));
+
+        f1 == f2; // returns false (metadata doesn't match)
+
+
+## bool operator!=(const [File](file.md) &other) {: #operator-ne }
+
+Compare [name](members.md#name) and [metadata](members.md#m_metadata) against another file name and metadata.
+
+* **function definition:**
+
+        inline bool operator!=(const File &other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to compare against
+
+* **output:** (bool) Returns true if the names and metadata are not equal, false otherwise.
+* **example:**
+
+        File f1("picture1.jpg");
+        File f2("picture1.jpg");
+
+        f1 != f2; // returns false
+
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f2.set("Key2", QVariant::fromValue<float>(2));
+
+        f1 != f2; // returns true (metadata doesn't match)
+
+
+## bool operator<(const [File](file.md) &other) {: #operator-lt }
+
+Compare [name](members.md#name) against another file name.
+
+* **function definition:**
+
+        inline bool operator<(const File &other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to compare against
+
+* **output:** (bool) Returns true if [name](members.md#name) < others.name
+
+
+## bool operator<=(const [File](file.md) &other) {: #operator-lte }
+
+Compare [name](members.md#name) against another file name.
+
+* **function definition:**
+
+        inline bool operator<=(const File &other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to compare against
+
+* **output:** (bool) Returns true if [name](members.md#name) <= others.name
+
+
+## bool operator>(const [File](file.md) &other) {: #operator-gt }
+
+Compare [name](members.md#name) against another file name.
+
+* **function definition:**
+
+        inline bool operator>(const File &other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to compare against
+
+* **output:** (bool) Returns true if [name](members.md#name) > others.name
+
+
+## bool operator>=(const [File](file.md) &other) {: #operator-gte }
+
+Compare [name](members.md#name) against another file name.
+
+* **function definition:**
+
+        inline bool operator>=(const File &other) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [File](file.md) & | File to compare against
+
+* **output:** (bool) Returns true if [name](members.md#name) >= others.name
+
+
+## bool isNull() {: #isnull }
+
+Check if the file is null.
+
+* **function definition:**
+
+        inline bool isNull() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if [name](members.md#name) and [metadata](members.md#m_metadata) are empty, false otherwise.
+* **example:**
+
+        File f;
+        f.isNull(); // returns true
+
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.isNull(); // returns false
+
+
+## bool isTerminal() {: #isterminal }
+
+Checks if the value of [name](members.md#name) == "terminal".
+
+* **function definition:**
+
+        inline bool isTerminal() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if [name](members.md#name) == "terminal", false otherwise.
+* **example:**
+
+        File f1("terminal"), f2("not_terminal");
+
+        f1.isTerminal(); // returns true
+        f2.isTerminal(); // returns false
+
+
+## bool exists() {: #exists }
+
+Check if the file exists on disk.
+
+* **function definition:**
+
+        inline bool exists() const
+
+* **parameters:** NONE
+* **output:** Returns true if [name](members.md#name) exists on disk, false otherwise.
+* **example:**
+
+    File f1("/path/to/file/that/exists"), f2("/path/to/non/existant/file");
+
+    f1.exists(); // returns true
+    f2.exists(); // returns false
+
+
+## [QString][QString] fileName() {: #filename }
+
+Get the file's base name and extension.
+
+* **function definition:**
+
+        inline QString fileName() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the base name + extension of [name](members.md#name)
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.fileName(); // returns "picture.jpg"
+
+
+## [QString][QString] baseName() {: #basename }
+
+Get the file's base name.
+
+* **function definition:**
+
+        inline QString baseName() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the base name of [name](members.md#name)
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.baseName(); // returns "picture"
+
+
+## [QString][QString] suffix() {: #suffix }
+
+Get the file's extension.
+
+* **function definition:**
+
+        inline QString suffix() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the extension of [name](members.md#name)
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.suffix(); // returns "jpg"
+
+
+## [QString][QString] path() {: #path }
+
+Get the path of the file without the name.
+
+* **function definition:**
+
+        inline QString path() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the path of [name](members.md#name).
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.suffix(); // returns "../path/to/pictures"
+
+
+## [QString][QString] resolved() {: #resolved }
+
+Get the full path for the file. This is done in three steps:
+
+1. If [name](members.md#name) exists, return [name](members.md#name).
+2. Prepend each path stored in [Globals->path](../context/members.md#path) to [name](members.md#name). If the combined name exists then it is returned.
+3. Prepend each path stored in [Globals->path](../context/members.md#path) to [fileName](#filename). If the combined name exists then it is returned.
+
+If none of the attempted names exist, [name](members.md#name) is returned unmodified.
+
+* **function definition:**
+
+        QString resolved() const
+
+* **parameters:** NONE
+* **output:** ([QString][QString]) Returns the resolved string if it can be created. Otherwise it returns [name](members.md#name)
+
+
+## bool contains(const [QString][QString] &key) {: #contains-1 }
+
+Check if a given key is in the local [metadata](members.md#m_metadata).
+
+* **function definition:**
+
+        bool contains(const QString &key) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to check the [metadata](members.md#m_metadata) for
+
+* **output:** (bool) Returns true if the given key is in the [metadata](members.md#m_metadata), false otherwise.
+* **example:**
+
+        File file;
+        file.set("Key1", QVariant::fromValue<float>(1));
+
+        file.contains("Key1"); // returns true
+        file.contains("Key2"); // returns false
+
+
+## bool contains(const [QStringList][QStringList] &keys) {: #contains-2 }
+
+Check if a list of keys is in the local [metadata](members.md#m_metadata).
+
+* **function definition:**
+
+        bool contains(const QStringList &keys) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    keys | const [QStringList][QStringList] & | Keys to check the [metadata](members.md#m_metadata) for
+
+* **output:** (bool) Returns true if *all* of the given keys are in the [metadata](members.md#m_metadata), false otherwise.
+* **example:**
+
+        File file;
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.set("Key2", QVariant::fromValue<float>(2));
+
+        file.contains(QStringList("Key1")); // returns true
+        file.contains(QStringList() << "Key1" << "Key2") // returns true
+        file.contains(QStringList() << "Key1" << "Key3"); // returns false
+
+
+## [QVariant][QVariant] value(const [QString][QString] &key) {: #value }
+
+Get the value associated with a given key from the [metadata](members.md#m_metadata). If the key is not found in the [local metadata](members.md#m_metadata), the [global metadata](../context/context.md) is searched. In a special case, the key can be "name". This returns the file's [name](members.md#name).
+
+* **function description:**
+
+        QVariant value(const QString &key) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to look up the value in the [local metadata](members.md#m_metadata) or [global metadata](../context/context.md). The key can also be "name".
+
+* **output:** ([QVariant][QVariant]) Returns the key associated with the value from either the [local](members.md#m_metadata) or [global](../context/context.md) metadata. If the key is "name", [name](members.md#name) is returned.
+* **example:**
+
+        File file;
+        file.set("Key1", QVariant::fromValue<float>(1));
+        file.value("Key1"); // returns QVariant(float, 1)
+
+
+## void set(const [QString][QString] &key, const [QVariant][QVariant] &value) {: #set-1 }
+
+Insert a value into the [metadata](members.md#m_metadata) using a provided key. If the key already exists the new value will override the old one.
+
+* **function description:**
+
+        inline void set(const QString &key, const QVariant &value)
+
+* **parameters:**
+
+    Parameters | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to store the given value in the [metadata](members.md#m_metadata)
+    value | const [QVariant][QVariant] & | Value to be stored
+
+* **output:** (void)
+* **example:**
+
+        File f;
+        f.flat(); // returns ""
+
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.flat(); // returns "[Key1=1]"
+
+
+## void set(const [QString][QString] &key, const [QString][QString] &value) {: #set-2 }
+
+Insert a value into the [metadata](members.md#m_metadata) using a provided key. If the key already exists the new value will override the old one.
+
+* **function description:**
+
+        void set(const QString &key, const QString &value)
+
+* **parameters:**
+
+    Parameters | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to store the given value in the [metadata](members.md#m_metadata)
+    value | const [QString][QString] & | Value to be stored
+
+* **output:** (void)
+* **example:**
+
+        File f;
+        f.flat(); // returns ""
+
+        f.set("Key1", QString("1"));
+        f.flat(); // returns "[Key1=1]"
+
+
+## void setList(const [QString][QString] &key, const [QList][QList]&lt;T&gt; &value) {: #setlist }
+
+Insert a list into the [metadata](members.md#m_metadata) using a provided key. If the key already exists the new value will override the old one. The value should be queried with [getList](#getlist-1) instead of [get](#get-1).
+
+* **function description:**
+
+        template <typename T> void setList(const QString &key, const QList<T> &value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to store the given value in the [metadata](members.md#m_metadata)
+    value | const [QList][QList]&lt;T&gt; | List to be stored
+
+* **output:** (void)
+* **see:** [getList](#getlist-1), [get](#get-1)
+* **example:**
+
+        File file;
+
+        QList<float> list = QList<float>() << 1 << 2 << 3;
+        file.setList<float>("List", list);
+        file.getList<float>("List"); // return [1., 2. 3.]
+
+
+## void remove(const [QString][QString] &key) {: #remove }
+
+Remove a key-value pair from the [metadata](members.md#m_metadata)
+
+* **function description:**
+
+        inline void remove(const QString &key)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to be removed from [metadata](members.md#m_metadata) along with its associated value.
+
+* **output:** (void)
+* **example:**
+
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
+        f.set("Key2", QVariant::fromValue<float>(2));
+
+        f.flat(); // returns "[Key1=1, Key2=2]"
+
+        f.remove("Key1");
+        f.flat(); // returns "[Key2=2]"
+
+
+## T get(const [QString][QString] &key) {: #get-1 }
+
+Get a value from the [metadata](members.md#m_metadata) using a provided key. If the key does not exist or the value cannot be converted to a user specified type an error is thrown.
+
+* **function definition:**
+
+        template <typename T> T get(const QString &key) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from [metadata](members.md#m_metadata)
+
+* **output:** (<tt>T</tt>) Returns a value of type <tt>T</tt>. <tt>T</tt> is a user specified type. The value associated with the given key must be convertable to <tt>T</tt>.
+* **see:** [get](#get-2), [getList](#getlist-1)
+* **example:**
+
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
+
+        f.get<float>("Key1");  // returns 1
+        f.get<float>("Key2");  // Error: Key2 is not in the metadata
+        f.get<QRectF>("Key1"); // Error: A float can't be converted to a QRectF
+
+## T get(const [QString][QString] &key, const T &defaultValue) {: #get-2 }
+
+Get a value from the [metadata](members.md#m_metadata) using a provided key. If the key does not exist or the value cannot be converted to user specified type a provided default value is returned instead.
+
+* **function definition:**
+
+        template <typename T> T get(const QString &key, const T &defaultValue)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](members.md#m_metadata)
+    defaultValue | const T & | Default value to be returned if the key does not exist or found value cannot be converted to <tt>T</tt>. <tt>T</tt> is a user specified type.
+
+* **output:** (<tt>T</tt>) Returns a value of type <tt>T</tt>. <tt>T</tt> is a user specified type. If the value associated with the key is invalid, the provided default value is returned instead.
+* **see:** [get](#get-1), [getList](#getlist-1)
+* **example:**
+
+        File f;
+        f.set("Key1", QVariant::fromValue<float>(1));
+
+        f.get<float>("Key1", 5);  // returns 1
+        f.get<float>("Key2", 5);  // returns 5
+        f.get<QRectF>("Key1", QRectF(0, 0, 10, 10)); // returns QRectF(0, 0, 10x10)
+
+
+## bool getBool(const [QString][QString] &key, bool defaultValue = false) {: #getbool }
+
+Get a boolean value from the [metadata](members.md#m_metadata) using a provided key. If the key is not in the [metadata](members.md#m_metadata) a provided default value is returned. If the key is in the metadata but the value cannot be converted to a bool true is returned. If the key is found and the value can be converted to a bool the value is returned.
+
+* **function definition:**
+
+        bool getBool(const QString &key, bool defaultValue = false) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](members.md#m_metadata)
+    defaultValue | bool | (Optional) Default value to be returned if the key is not in the [metadata](members.md#m_metadata).
+
+* **output:** (bool) If the key *is not* in the [metadata](members.md#m_metadata) the provided default value is returned. If the key *is* in the [metadata](members.md#m_metadata) but the associated value *cannot* be converted to a bool true is returned. If the key *is* in the [metadata](members.md#m_metadata) and the associated value *can* be converted to a bool, that value is returned.
+* **see:** [get](#get-2)
+* **example:**
+
+        File f;
+        f.set("Key1", QVariant::fromValue<bool>(true));
+        f.set("Key2", QVariant::fromValue<float>(10));
+
+        f.getBool("Key1");       // returns true
+        f.getBool("Key2")        // returns true (key found)
+        f.getBool("Key3");       // returns false (default value)
+        f.getBool("Key3", true); // returns true (default value)
+
+
+## [QList][QList]&lt;T&gt; getList(const [QString][QString] &key) {: #getlist-1 }
+
+Get a list from the [metadata](members.md#m_metadata) using a provided key. If the key does not exist or the elements of the list cannot be converted to a user specified type an error is thrown.
+
+* **function definition:**
+
+        template <typename T> QList<T> getList(const QString &key) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](members.md#m_metadata)
+
+* **output:** ([QList][QList]&lt;<tt>T</tt>&gt;) Returns a list of values of a user specified type.
+* **see:** [setList](#setlist), [get](#get-1)
+* **example:**
+
+        File file;
+
+        QList<float> list = QList<float>() << 1 << 2 << 3;
+        file.setList<float>("List", list);
+
+        file.getList<float>("List");  // return [1., 2. 3.]
+        file.getList<QRectF>("List"); // Error: float cannot be converted to QRectF
+        file.getList<float>("Key");   // Error: key doesn't exist
+
+
+## [QList][QList]&lt;T&gt; getList(const [QString][QString] &key, const [QList][QList]&lt;T&gt; defaultValue) {: #getlist-2 }
+
+Get a list from the [metadata](members.md#m_metadata) using a provided key. If the key does not exist or the elements of the list cannot be converted to a user specified type a provided default value is returned.
+
+* **function definition:**
+
+template <typename T> QList<T> getList(const QString &key, const QList<T> defaultValue) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to retrieve a value from the [metadata](members.md#m_metadata)
+    defaultValue | [QList][QList]&lt;<tt>T</tt> | (Optional) Default value to be returned if the key is not in the [metadata](members.md#m_metadata).
+
+* **output:** ([QList][QList]&lt;<tt>T</tt>&gt;) Returns a list of values of user specified type. If key is not in the [metadata](members.md#m_metadata) or if the value cannot be converted to a [QList][QList]&lt;<tt>T</tt>&gt; the default value is returned.
+* **see:** [getList](#getlist-1)
+* **example:**
+
+        File file;
+
+        QList<float> list = QList<float>() << 1 << 2 << 3;
+        file.setList<float>("List", list);
+
+        file.getList<float>("List", QList<float>());                  // return [1., 2. 3.]
+        file.getList<QRectF>("List", QList<QRectF>());                // return []
+        file.getList<float>("Key", QList<float>() << 1 << 2 << 3);    // return [1., 2., 3.]
+
+
+## [QList][QList]&lt;[QPointF][QPointF]&gt; namedPoints() {: #namedpoints }
+
+Find values in the [metadata](members.md#m_metadata) that can be converted into [QPointF][QPointF]'s. Values stored as [QList][QList]&lt;[QPointF][QPointF]&gt; *will not** be returned.
+
+* **function definition:**
+
+        QList<QPointF> namedPoints() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QPointF][QPointF]&gt;) Returns a list of points that can be converted from [metadata](members.md#m_metadata) values.
+* **example:**
+
+        File file;
+        file.set("Key1", QVariant::fromValue<QPointF>(QPointF(1, 1)));
+        file.set("Key2", QVariant::fromValue<QPointF>(QPointF(2, 2)));
+        file.set("Points", QVariant::fromValue<QPointF>(QPointF(3, 3)))
+
+        f.namedPoints(); // returns [QPointF(1, 1), QPointF(2, 2), QPointF(3, 3)]
+
+        file.setPoints(QList<QPointF>() << QPointF(3, 3)); // changes metadata["Points"] to QList<QPointF>
+        f.namedPoints(); // returns [QPointF(1, 1), QPointF(2, 2)]
+
+
+## [QList][QList]&lt;[QPointF][QPointF]&gt; points() {: #points }
+
+Get values stored in the [metadata](members.md#m_metadata) with key "Points". It is expected that this field holds a [QList][QList]&lt;[QPointf][QPointF]>&gt;.
+
+* **function definition:**
+
+        QList<QPointF> points() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QPointf][QPointF]>&gt;) Returns a list of points stored at [metadata](members.md#m_metadata)["Points"]
+* **see:** [appendPoint](#appendpoint), [appendPoints](#appendpoints), [clearPoints](#clearpoints), [setPoints](#setpoints)
+* **example:**
+
+        File file;
+        file.set("Points", QVariant::fromValue<QPointF>(QPointF(1, 1)));
+        file.points(); // returns [] (point is not in a list)
+
+        file.setPoints(QList<QPointF>() << QPointF(2, 2));
+        file.points(); // returns [QPointF(2, 2)]
+
+
+## void appendPoint(const [QPointF][QPointF] &point) {: #appendpoint }
+
+Append a point to the [QList][QList]&lt;[QPointF][QPointF]&gt; stored at [metadata](members.md#m_metadata)["Points"].
+
+* **function definition:**
+
+        void appendPoint(const QPointF &point)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    point | const [QPoint][QPoint] & | Point to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.points(); // returns []
+
+        file.appendPoint(QPointF(1, 1));
+        file.points(); // returns [QPointF(1, 1)]
+
+
+## void appendPoints(const [QList][QList]&lt;[QPointF][QPointF]&gt; &points) {: #appendpoints }
+
+Append a list of points to the [QList][QList]&lt;[QPointF][QPointF]&gt; stored at [metadata](members.md#m_metadata)["Points"].
+
+* **function definition:**
+
+        void appendPoints(const QList<QPointF> &points)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    points | const [QList][QList]&lt;[QPointF][QPointF]&gt; & | List of points to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.points(); // returns []
+
+        file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
+        file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
+
+
+## void clearPoints() {: #clearpoints }
+
+Remove all points stored at [metadata](members.md#m_metadata)["Points"].
+
+* **function definition:**
+
+        inline void clearPoints()
+
+* **parameters:** NONE
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
+        file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
+
+        file.clearPoints();
+        file.points(); // returns []
+
+
+## void setPoints(const [QList][QList]&lt;[QPointF][QPointF]&gt; &points) {: #setpoints }
+
+Replace the points stored at [metadata](members.md#m_metadata)["Points"]
+
+* **function definition:**
+
+        inline void setPoints(const QList<QPointF> &points)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    points | const [QList][QList]&lt;[QPointF][QPointF]&gt; & | Points to overwrite [metadata](members.md#m_metadata) with
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendPoints(QList<QPointF>() << QPointF(1, 1) << QPointF(2, 2));
+        file.points(); // returns [QPointF(1, 1), QPointF(2, 2)]
+
+        file.setPoints(QList<QPointF>() << QPointF(3, 3) << QPointF(4, 4));
+        file.points(); // returns [QPointF(3, 3), QPointF(4, 4)]
+
+
+## [QList][QList]&lt;[QRectF][QRectF]&gt; namedRects() {: #namedrects }
+
+Find values in the [metadata](members.md#m_metadata) that can be converted into [QRectF][QRectF]'s. Values stored as [QList][QList]&lt;[QRectF][QRectF]&gt; *will not** be returned.
+
+* **function definition:**
+
+        QList<QRectF> namedRects() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QRectF][QRectF]&gt;) Returns a list of rects that can be converted from [metadata](members.md#m_metadata) values.
+* **example:**
+
+        File file;
+        file.set("Key1", QVariant::fromValue<QRectF>(QRectF(1, 1, 5, 5)));
+        file.set("Key2", QVariant::fromValue<QRectF>(QRectF(2, 2, 5, 5)));
+        file.set("Rects", QVariant::fromValue<QRectF>(QRectF(3, 3, 5, 5)));
+
+        f.namedRects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5), QRectF(3, 3, 5x5)]
+
+        file.setRects(QList<QRectF>() << QRectF(3, 3, 5x5)); // changes metadata["Rects"] to QList<QRectF>
+        f.namedRects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+
+## [QList][QList]&lt;[QRectF][QRectF]&gt; rects() {: #rects }
+
+Get values stored at [metadata](members.md#m_metadata)["Rects"]. It is expected that this field holds a [QList][QList]&lt;[QRectf][QRectF]>&gt;.
+
+* **function definition:**
+
+        QList<QRectF> points() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[QRectf][QRectF]>&gt;) Returns a list of rects stored at [metadata](members.md#m_metadata)["Rects"]
+* **see:** [appendRect](#appendrect-1), [appendRects](#appendrects-1), [clearRects](#clearrects), [setRects](#setrects-1)
+* **example:**
+
+        File file;
+        file.set("Rects", QVariant::fromValue<QRectF>(QRectF(1, 1, 5, 5)));
+        file.rects(); // returns [] (rect is not in a list)
+
+        file.setRects(QList<QRectF>() << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(2, 2, 5x5)]
+
+
+## void appendRect(const [QRectF][QRectF] &rect) {: #appendrect-1 }
+
+Append a rect to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](members.md#m_metadata)["Rects"].
+
+* **function definition:**
+
+        void appendRect(const QRectF &rect)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rect | const [QRect][QRect] & | Rect to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.rects(); // returns []
+
+        file.appendRect(QRectF(1, 1, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5)]
+
+
+## void appendRect(const [Rect][Rect] &rect) {: #appendrect-2 }
+
+Append an OpenCV-style [Rect][Rect] to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](members.md#m_metadata)["Rects"]. Supplied OpenCV-style rects are converted to [QRectF][QRectF] before being appended.
+
+* **function definition:**
+
+        void appendRect(const Rect &rect)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rect | const [Rect][Rect] & | OpenCV-style rect to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.rects(); // returns []
+
+        file.appendRect(cv::Rect(1, 1, 5, 5)); // automatically converted to QRectF
+        file.rects(); // returns [QRectF(1, 1, 5x5)]
+
+
+## void appendRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects) {: #appendrects-1 }
+
+Append a list of rects to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](members.md#m_metadata)["Rects"].
+
+* **function definition:**
+
+        void appendRects(const QList<QRectF> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[QRectF][QRectF]&gt; & | List of rects to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.rects(); // returns []
+
+        file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+
+## void appendRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects) {: #appendrects-2 }
+
+Append a list of OpenCV-style [Rects][Rect] to the [QList][QList]&lt;[QRectF][QRectF]&gt; stored at [metadata](members.md#m_metadata)["Rects"]. Supplied OpenCV-style rects are converted to [QRectF][QRectF] before being appended.
+
+* **function definition:**
+
+        void appendRects(const QList<QRectF> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[Rect][Rect]&gt; & | List of OpenCV-style rects to be appended
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.rects(); // returns []
+
+        file.appendRects(QList<Rect>() << Rect(1, 1, 5, 5) << Rect(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+## void clearRects() {: #clearrects }
+
+Remove all points stored at [metadata](members.md#m_metadata)["Rects"].
+
+* **function definition:**
+
+        inline void clearRects()
+
+* **parameters:** NONE
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+        file.clearRects();
+        file.rects(); // returns []
+
+
+## void setRects(const [QList][QList]&lt;[QRectF][QRectF]&gt; &rects) {: #setrects-1 }
+
+Replace the rects stored at [metadata](members.md#m_metadata) with a provided list of rects.
+
+* **function definition:**
+
+        inline void setRects(const QList<QRectF> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[QRectF][QRectF]&gt; & | Rects to overwrite [metadata](members.md#m_metadata)["Rects"] with
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendRects(QList<QRectF>() << QRectF(1, 1, 5, 5) << QRectF(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+        file.setRects(QList<QRectF>() << QRectF(3, 3, 5, 5) << QRectF(4, 4, 5, 5));
+        file.rects(); // returns [QRectF(3, 3, 5x5), QRectF(4, 4, 5x5)]
+
+
+## void setRects(const [QList][QList]&lt;[Rect][Rect]&gt; &rects) {: #setrects-2 }
+
+Replace the rects stored at [metadata](members.md#m_metadata) with a provided list of OpenCV-style [Rects][Rect].
+
+* **function definition:**
+
+        inline void setRects(const QList<Rect> &rects)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rects | const [QList][QList]&lt;[Rect][Rect]&gt; & | OpenCV-style rects to overwrite [metadata](members.md#m_metadata)["Rects"] with
+
+* **output:** (void)
+* **example:**
+
+        File file;
+        file.appendRects(QList<cv::Rect>() << cv::Rect(1, 1, 5, 5) << cv::Rect(2, 2, 5, 5));
+        file.rects(); // returns [QRectF(1, 1, 5x5), QRectF(2, 2, 5x5)]
+
+        file.setRects(QList<cv::Rect>() << cv::Rect(3, 3, 5, 5) << cv::Rect(4, 4, 5, 5));
+        file.rects(); // returns [QRectF(3, 3, 5x5), QRectF(4, 4, 5x5)]
+
+<!-- Links -->
+[Qt]: http://qt-project.org/ "Qt"
+[QApplication]: http://doc.qt.io/qt-5/qapplication.html "QApplication"
+[QCoreApplication]: http://doc.qt.io/qt-5/qcoreapplication.html "QCoreApplication"
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+[Qt Property System]: http://doc.qt.io/qt-5/properties.html "Qt Property System"
+
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QMap]: http://doc.qt.io/qt-5/qmap.html "QMap"
+[QHash]: http://doc.qt.io/qt-5/qhash.html "QHash"
+
+[QRectF]: http://doc.qt.io/qt-5/qrectf.html "QRectF"
+[QPoint]: http://doc.qt.io/qt-5/qpoint.html "QPoint"
+[QPointF]: http://doc.qt.io/qt-5/qpointf.html "QPointF"
+
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[QVariantList]: http://doc.qt.io/qt-5/qvariant.html#QVariantList-typedef "QVariantList"
+[QVariantMap]: http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef "QVariantMap"
+
+[QRegExp]: http://doc.qt.io/qt-5/QRegExp.html "QRegExp"
+[QThread]: http://doc.qt.io/qt-5/qthread.html "QThread"
+[QFile]: http://doc.qt.io/qt-5/qfile.html "QFile"
+
+[QSharedPointer]: http://doc.qt.io/qt-5/qsharedpointer.html "QSharedPointer"
+
+[QTime]: http://doc.qt.io/qt-5/QTime.html "QTime"
+[QDebug]: http://doc.qt.io/qt-5/qdebug.html "QDebug"
+[QDataStream]: http://doc.qt.io/qt-5/qdatastream.html "QDataStream"
+[QByteArray]: http://doc.qt.io/qt-5/qbytearray.html "QByteArray"
+
+[R]: http://www.r-project.org/ "R"
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+[Rect]: http://docs.opencv.org/modules/core/doc/basic_structures.html#rect "Rect"
+[InputArray]: http://docs.opencv.org/modules/core/doc/basic_structures.html#inputarray "InputArray"
+[OutputArray]: http://docs.opencv.org/modules/core/doc/basic_structures.html#outputarray "OutputArray"
+[OpenCV Image Formats]: http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imread#imread "OpenCV Image Formats"
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id="name"></a>name | [QString][QString] | Path to a file on disk
+<a class="table-anchor" id=fte></a>fte | bool | Failed to enroll. If true this file failed to be processed somewhere in the template enrollment algorithm
+<a class="table-anchor" id=m_metadata></a>m_metadata | [QVariantMap][QVariantMap] | Map for storing metadata. It is a [QString][QString], [QVariant][QVariant] key value pairing.
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[QVariantMap]: http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef "QVariantMap"
+## [QVariant][QVariant] parse(const [QString][QString] &value) {: #parse }
+
+Try to convert a given value to a [QPointF][QPointF], [QRectF][QRectF], int or float.
+
+* **function definition:**
+
+        static QVariant parse(const QString &value);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    value | const [QString][QString] & | String value to be converted.
+
+* **output:** ([QVariant][QVariant]) The converted file if a conversion was possible. Otherwise the unconverted string is returned.
+* **example:**
+
+        QString point = "(1, 1)";
+        QString rect = "(1, 1, 5, 5)";
+        QString integer = "1";
+        QString fp = "1.0";
+        QString string = "Hello World";
+
+        File::parse(point);   // returns QVariant(QPointF, QPointF(1, 1))
+        File::parse(rect);    // returns QVariant(QRectF, QRectF(1, 1, 5x5))
+        File::parse(integer); // returns QVariant(int, 1)
+        File::parse(fp);      // returns QVariant(float, 1.0f)
+        File::parse(string);  // returns QVariant(QString, "Hello World")
+
+
+## [QList][QList]&lt;[QVariant][QVariant]&gt; values(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key) {: #values }
+
+Gather a list of [QVariant][QVariant] values associated with a metadata key from a provided list of files.
+
+* **function definition:**
+
+        template<class U> static [QList<QVariant> values(const QList<U> &fileList, const QString &key)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    fileList | const [QList][QList]&lt;U&gt; & | A list of files to parse for values. A type is required for <tt>U</tt>. Valid options are: <ul> <li>[File](file.md)</li> <li>[QString][QString]</li> </ul>
+    key | const [QString][QString] & | A metadata key used to lookup the values.
+
+* **output:** ([QList][QList]&lt;[QVariant][QVariant]&gt;) A list of [QVariant][QVariant] values associated with the given key in each of the provided files.
+* **example:**
+
+        File f1, f2;
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f1.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key1", QVariant::fromValue<float>(3));
+
+        File::values<File>(QList<File>() << f1 << f2, "Key1"); // returns [QVariant(float, 1),
+                                                               //          QVariant(float, 3)]
+
+
+## [QList][QList]&lt;T&gt; get(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key) {: #get-1 }
+
+Gather a list of <tt>T</tt> values associated with a metadata key from a provided list of files. <tt>T</tt> is a user provided type. If the key does not exist in the metadata of *any* file an error is thrown.
+
+* **function definition:**
+
+        template<class T, class U> static QList<T> get(const QList<U> &fileList, const QString &key)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    fileList | const [QList][QList]&lt;U&gt; & | A list of files to parse for values. A type is required for U. Valid options are: <ul> <li>[File](file.md)</li> <li>[QString][QString]</li> </ul>
+    key | const [QString][QString] & | A metadata key used to lookup the values.
+
+* **output:** ([QList][QList]&lt;T&gt;) A list of the values of type <tt>T</tt> associated with the given key. A type is required for <tt>T</tt>.
+* **example:**
+
+        File f1, f2;
+        f1.set("Key1", QVariant::fromValue<float>(1));
+        f1.set("Key2", QVariant::fromValue<float>(2));
+        f2.set("Key1", QVariant::fromValue<float>(3));
+
+        File::get<float, File>(QList<File>() << f1 << f2, "Key1");  // returns [1., 3.]
+        File::get<float, File>(QList<File>() << f1 << f2, "Key2");  // Error: Key doesn't exist in f2
+        File::get<QRectF, File>(QList<File>() << f1 << f2, "Key1"); // Error: float is not convertable to QRectF
+
+
+## [QList][QList]&lt;T&gt; get(const [QList][QList]&lt;U&gt; &fileList, const [QString][QString] &key, const T &defaultValue) {: #get-2 }
+
+Gather a list of <tt>T</tt> values associated with a metadata key from a provided list of files. <tt>T</tt> is a user provided type. If the key does not exist in the metadata of *any* file the provided **defaultValue** is used.
+
+* **function definition:**
+
+        template<class T, class U> static QList<T> get(const QList<U> &fileList, const QString &key, const T &defaultValue)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    fileList | const [QList][QList]&lt;U&gt; & | A list of files to parse for values. A type is required for U. Valid options are: <ul> <li>[File](file.md)</li> <li>[QString][QString]</li> </ul>
+    key | const [QString][QString] & | A metadata key used to lookup the values.
+    defaultValue | const T & | The default value if the key is not in a file's metadata. A type is required for T. All types are valid.
+
+* **output:** ([QList][QList]&lt;T&gt;) A list of the values of type <tt>T</tt> associated with the given key. A type is required for <tt>T</tt>.
+* **example:**
+
+    File f1, f2;
+    f1.set("Key1", QVariant::fromValue<float>(1));
+    f1.set("Key2", QVariant::fromValue<float>(2));
+    f2.set("Key1", QVariant::fromValue<float>(3));
+
+    File::get<float, File>(QList<File>() << f1 << f2, "Key1");                       // returns [1., 3.]
+    File::get<float, File>(QList<File>() << f1 << f2, "Key2", QList<float>() << 1);  // returns [1.]
+    File::get<QRectF, File>(QList<File>() << f1 << f2, "Key1, QList<QRectF>()");     // returns []
+
+
+## [QDebug][QDebug] operator <<([QDebug][QDebug] dbg, const [File](file.md) &file) {: #dbg-operator-ltlt }
+
+Calls [flat](functions.md#flat) on the given file and then streams that file to stderr.
+
+* **function definition:**
+
+        QDebug operator <<(QDebug dbg, const File &file)
+
+* **parameter:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    dbg | [QDebug][QDebug] | The debug stream
+    file | const [File](file.md) & | File to stream
+
+* **output:** ([QDebug][QDebug] &) returns a reference to the updated debug stream
+* **example:**
+
+        File file("../path/to/pictures/picture.jpg");
+        file.set("Key", QString("Value"));
+
+        qDebug() << file; // "../path/to/pictures/picture.jpg[Key=Value]" streams to stderr
+
+
+## [QDataStream][QDataStream] &operator <<([QDataStream][QDatastream] &stream, const [File](file.md) &file) {: #stream-operator-ltlt }
+
+Serialize a file to a data stream.
+
+* **function definition:**
+
+        QDataStream &operator <<(QDataStream &stream, const File &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] | The data stream
+    file | const [File](file.md) & | File to stream
+
+* **output:** ([QDataStream][QDataStream] &) returns a reference to the updated data stream
+* **example:**
+
+        void store(QDataStream &stream)
+        {
+            File file("../path/to/pictures/picture.jpg");
+            file.set("Key", QString("Value"));
+
+            stream << file; // "../path/to/pictures/picture.jpg[Key=Value]" serialized to the stream
+        }
+
+
+## [QDataStream][QDataStream] &operator >>([QDataStream][QDataStream] &stream, const [File](file.md) &file) {: #stream-operator-gtgt }
+
+Deserialize a file from a data stream.
+
+* **function definition:**
+
+        QDataStream &operator >>(QDataStream &stream, const File &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] | The data stream
+    file | const [File](file.md) & | File to stream
+
+* **output:** ([QDataStream][QDataStream] &) returns a reference to the updated data stream
+* **example:**
+
+        void load(QDataStream &stream)
+        {
+            File in("../path/to/pictures/picture.jpg");
+            in.set("Key", QString("Value"));
+
+            stream << in; // "../path/to/pictures/picture.jpg[Key=Value]" serialized to the stream
+
+            File out;
+            stream >> out;
+
+            out.name; // returns "../path/to/pictures/picture.jpg"
+            out.flat(); // returns "../path/to/pictures/picture.jpg[Key=Value]"
+        }
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QDebug]: http://doc.qt.io/qt-5/qdebug.html "QDebug"
+[QDataStream]: http://doc.qt.io/qt-5/qdatastream.html "QDataStream"
+[QRectF]: http://doc.qt.io/qt-5/qrectf.html "QRectF"
+[QPointF]: http://doc.qt.io/qt-5/qpointf.html "QPointF"
+Constructor / Destructor | Description
+--- | ---
+virtual ~FileGallery() | Default destructor. Closes [f](members.md#f)
 \ No newline at end of file
+<!-- FILE GALLERY -->
+
+Inherits [Gallery](../gallery/gallery.md)
+
+A [Gallery](../gallery/gallery.md) that handles data stored on disk (as opposed to data already in memory).
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Functions](functions.md)
+
+[FileGalleries](filegallery.md) are the base abstraction for all [Galleries](../gallery/gallery.md) that handle I/O with the hard drive. They automatically track the size and current position of a file and also provide convienience opererators for opening them for reading and writing.
+## void init() {: #init }
+
+Initialize the [FileGallery](filegallery.md). This sets [f](members.md#f) using the file name from [file](../object/members.md#file). It also calls [Gallery](../gallery/gallery.md)::[init](../object/functions.md#init).
+
+* **function definition:**
+
+        void init()
+
+* **parameters:** NONE
+* **output:** (void)
+
+## qint64 totalSize() {: #totalsize }
+
+Get the total size of the file. This is useful for estimating progress.
+
+* **function definition:**
+
+        qint64 totalSize()
+
+* **parameters:** NONE
+* **output:** (qint64) Returns the total size of the file in bytes
+
+## qint64 position() {: #pos }
+
+Get the current index in the file. This is useful for reading and writing blocks of data
+
+* **function definition:**
+
+        qint64 position()
+
+* **parameters:** NONE
+* **output:** (qint64) Returns the current position in the file
+
+## bool readOpen() {: #readopen }
+
+Open [f](members.md#f) in read-only mode
+
+* **function definition:**
+
+        bool readOpen()
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if the file was opened successfully, false otherwise
+
+## void writeOnly() {: #writeonly }
+
+Open [f](members.md#f) in write-only mode
+
+* **function definition:**
+
+        void writeOpen()
+
+* **parameters:** NONE
+* **output:** (void)
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id="f"></a>f | [QFile][QFile] | The file on disk. It has the same name as [file](../object/members.md#file)
+
+<!-- Links -->
+[QFile]: http://doc.qt.io/qt-5/qfile.html "QFile"
+Constructor | Description
+--- | ---
+FileList() | Default constructor. Doesn't do anything.
+FileList(int n) | Intialize the [FileList](filelist.md) with n empty [Files](../file/file.md)
+FileList(const [QStringList][QStringList] &files) | Initialize the [FileList](filelist.md) with a list of strings. Each string should have the format "filename[key1=value1, key2=value2, ... keyN=valueN]"
+FileList(const [QList][QList]&lt;[File](../file/file.md)&gt; &files) | Initialize the [FileList](filelist.md) from a list of [files](../file/file.md).
+
+<!-- Links -->
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+Inherits [QList][QList]&lt;[File](../file/file.md)&gt;.
+
+See:
+
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+A convenience class for dealing with lists of files.
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+## [QStringList][QStringList] flat() const {: #flat }
+
+Calls [flat](../file/functions.md#flat) on every [File](../file/file.md) in the list and returns the resulting strings as a [QStringList][QStringList].
+
+* **function definition:**
+
+        QStringList flat() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns a list of the output of calling [flat](../file/functions.md#flat) on each [File](../file/file.md)
+* **example:**
+
+        File f1("picture1.jpg"), f2("picture2.jpg");
+        f1.set("Key", QString("Value"));
+
+        FileList fList(QList<File>() << f1 << f2);
+        fList.flat(); // returns ["picture1.jpg[Key=Value]", "picture2.jpg"]
+
+
+## [QStringList][QStringList] names() const {: #names }
+
+Get the [names](../file/members.md#name) of every [File](../file/file.md) in the list.
+
+* **function definition:**
+
+        QStringList names() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns the [name](../file/members.md#name) of every [File](../file/file.md) in the list
+* **example:**
+
+        File f1("picture1.jpg"), f2("picture2.jpg");
+        f1.set("Key", QString("Value"));
+
+        FileList fList(QList<File>() << f1 << f2);
+        fList.names(); // returns ["picture1.jpg", "picture2.jpg"]
+
+
+## void sort(const [QString][QString] &key) {: #sort }
+
+Sort the [FileList](filelist.md) based on the values associated with a provided key in each [File](../file/file.md).
+
+* **function definition:**
+
+        void sort(const QString &key)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | Key to look up desired values in each [Files](../file/file.md) [metadata](../file/members.md#m_metadata)
+
+* **output:** (void)
+* **example:**
+
+        File f1("1"), f2("2"), f3("3");
+        f1.set("Key", QVariant::fromValue<float>(3));
+        f2.set("Key", QVariant::fromValue<float>(1));
+        f3.set("Key", QVariant::fromValue<float>(2));
+
+        FileList fList(QList<File>() << f1 << f2 << f3);
+        fList.names(); // returns ["1", "2", "3"]
+
+        fList.sort("Key");
+        fList.names(); // returns ["2", "3", "1"]
+
+
+## [QList][QList]&lt;int&gt; crossValidationPartitions() const {: #crossvalidationpartitions }
+
+Get the cross-validation partion of each [File](../file/file.md) in the list. The partition is stored in each [File](../file/file.md) at [metadata](../file/members.md#m_metadata)["Partition"].
+
+* **function definition:**
+
+        QList<int> crossValidationPartitions() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;int&gt;) Returns the cross-validation partion of each [File](../file/file.md) as a list. If a [File](../file/file.md) does not have the "Partition" field in it's [metadata](../file/members.md#m_metadata) 0 is used.
+* **example:**
+
+        File f1, f2, f3;
+        f1.set("Partition", QVariant::fromValue<int>(1));
+        f3.set("Partition", QVariant::fromValue<int>(3));
+
+        FileList fList(QList<File>() << f1 << f2 << f3);
+        fList.crossValidationPartitions(); // returns [1, 0, 3]
+
+
+## int failures() const {: #failures }
+
+Get the number of [Files](../file/file.md) in the list that have [failed to enroll](../file/members.md#fte).
+
+* **function definition:**
+
+        int failures() const
+
+* **parameters:** NONE
+* **output:** (int) Returns the number of [Files](../file/file.md) that have [fte](../file/members.md#fte) equal true.
+* **example:**
+
+        File f1, f2, f3;
+        f1.fte = false;
+        f2.fte = true;
+        f3.fte = true;
+
+        FileList fList(QList<File>() << f1 << f2 << f3);
+        fList.failures(); // returns 2
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+## [FileList](filelist.md) fromGallery(const [File](../file/file.md) &gallery, bool cache = false) {: #fromgallery }
+
+Create a [FileList](filelist.md) from a [Gallery](../gallery/gallery.md). Galleries store one or more [Templates](../template/template.md) on disk. Common formats include **csv**, **xml**, and **gal**, which is a unique OpenBR format. Read more about this in the [Gallery](../gallery/gallery.md) section. This function creates a [FileList](filelist.md) by parsing the stored gallery based on its format. Cache determines whether the gallery should be stored for faster reading later.
+
+* **function definition:**
+
+        static FileList fromGallery(const File &gallery, bool cache = false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | const [File](../file/file.md) & | Gallery file to be enrolled
+    cache | bool | (Optional) Retain the gallery in memory. Default is false.
+
+* **output:** ([FileList](filelist.md)) Returns the filelist that the gallery was enrolled into
+* **example:**
+
+        File gallery("gallery.csv");
+
+        FileList fList = FileList::fromGallery(gallery);
+        fList.flat(); // returns all the files that have been loaded from disk. It could
+                      // be 1 or 100 depending on what was stored.
+Constructor / Destructor | Description
+--- | ---
+virtual ~Format() | Default destructor. It doesn't do anything
+<!-- FORMAT -->
+
+Inherits [Object](../object/object.md)
+
+Plugin base class for reading a template from disk.
+
+See:
+
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+A *format* is a [File](../file/file.md) representing a [Template](../template/template.md) on disk. [File](../file/file.md)::[suffix](../file/functions.md#suffix) is used to determine which derived format plugin should handle a file. Currently supported extensions are:
+
+* [OpenCV image formats][OpenCV Image Formats]
+* xml
+* scores
+* url
+* raw
+* post
+* null
+* mtx
+* mask
+* mat
+* lffs
+* ebts
+* csv
+* binary
+
+Many of these extensions are unique to OpenBR. Please look at the relevant [Format plugin](../../../plugin_docs/format.md) for information on formatting and other concerns.
+
+<!-- Links -->
+[OpenCV Image Formats]: http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imread#imread "OpenCV Image Formats"
+## [Template](../template/template.md) read() {: #read }
+
+This is a pure virtual function. Read a template from disk at [file](../object/members.md#file).
+
+* **function definition:**
+
+        virtual Template read() const = 0
+
+* **parameters:** NONE
+* **output:** ([Template](../template/template.md)) Returns a template loaded from disk
+* **example:**
+
+        Format *format = Factory::make<Format>("picture.jpg")
+        format->read(); // returns a template loaded from "picture.jpg"
+
+## void write(const [Template](../template/template.md) &t) {: #write }
+
+This is a pure virtual function. Write a provide template to disk at [file](../object/members.md#file)
+
+* **function definition:**
+
+        virtual void write(const Template &t) const = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    t | const [Template](../template/template.md) & | [Template](../template/template.md) to write to disk
+
+* **output:** (void)
+* **example:**
+
+        Format *format = Factory::make<Format>("new_pic_location.jpg");
+
+        Template t("picture.jpg");
+        format->write(t); // write t to "new_pic_location"
+## [Template](../template/template.md) read(const [QString][QString] &file) {: #read }
+
+Read a [Template](../template/template.md) from disk at the provide file location. A derived class format is chosen based on the suffix of the provided file.
+
+* **function definition:**
+
+static Template read(const QString &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    file | const [QString][QString] & | File to load a [Template](../template/template.md) from.
+
+* **output:** ([Template](../template/template.md)) Returns a [Template](../template/template.md) loaded from disk.
+* **example:**
+
+        Format::read("picture.jpg"); // returns a template loaded from "picture.jpg". The proper Format to load jpg images is selected automatically
+
+
+## void write(const [QString][QString] &file, const [Template](../template/template.md) &t) {: #write }
+
+Write a template to disk at the provided file location.
+
+* **function definition:**
+
+        static void write(const QString &file, const Template &t)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    file | const [QString][QString] & | File to write a [Template](../template/template.md) to
+    t | const [Template](../template/template.md) & | [Template](../template/template.md) to write to disk
+
+* **output:** (void)
+* **example:**
+
+        Template t("picture.jpg");
+
+        Format::write("new_pic_location.jpg", t); // Write t to "new_pic_location.jpg"
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+Constructor / Destructor | Description
+--- | ---
+virtual ~Gallery() | Default Destructor. Derived classes should overload this to handle serialization to disk.
+## [TemplateList](../templatelist/templatelist.md) read() {: #read }
+
+Read all of them templates stored in the [Gallery](gallery.md) from disk into memory. For incremental reads see [readBlock](#readblock)
+
+* **function definition:**
+
+        TemplateList read()
+
+* **parameters:** NONE
+* **output:** ([TemplateList](../templatelist/templatelist.md)) Returns a list of all of the templates read from disk
+* **example:**
+
+        Gallery *gallery = Gallery::make("gallery_file.xml");
+        gallery->read(); // returns a TemplateList of every template stored in the gallery
+
+<!--no italics*-->
+
+## [FileList](../filelist/filelist.md) files() {: #files }
+
+Read all of the filese stored in the [Gallery](gallery.md) from disk into memory.
+
+* **function definition:**
+
+        FileList files()
+
+* **parameters:** NONE
+* **output:** ([FileList](../filelist/filelist.md)) Returns a list of all of the files read from disk
+* **example:**
+
+        Gallery *gallery = Gallery::make("gallery_file.xml");
+        gallery->files(); // returns a FileList of every file stored in the gallery
+
+<!--no italics*-->
+
+## [TemplateList](../templatelist/templatelist.md) readBlock(bool \*done) {: #readblock }
+
+This is a pure virtual function. Incrementally read a block of templates from disk into memory. The size of the block is set by [readBlockSize](properties.md#readblocksize).
+
+* **function definition:**
+
+        virtual TemplateList readBlock(bool *done) = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    done | bool \* | Set to true by the function if the last block has been read, false otherwise
+
+* **output:** ([TemplateList](../templatelist/templatelist.md)) Returns a block of templates loaded from disk
+* **example:**
+
+        Gallery *gallery = Gallery::make("gallery_file.xml");
+
+        bool done = false
+        while(!done)
+            gallery->readBlock(&done); // Each iteration of the loop reads a new block until the end of the gallery is reached
+
+<!--no italics*-->
+
+## void writeBlock(const [TemplateList](../templatelist/templatelist.md) &templates) {: #writeblock }
+
+Write the provided templates to disk. This function calls [write](#write) which should be overloaded by all derived classes. If the gallery is a linked list (see [make](statics.md#make)) each gallery writes the provided templates sequentially.
+
+* **function definition:**
+
+        void writeBlock(const TemplateList &templates)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    templates | const [TemplateList](../templatelist/templatelist.md) & | List of templates to write to disk
+
+* **output:** (void)
+* **example:**
+
+        Template t1("picture1.jpg");
+        t1.file.set("property", 1);
+        Template t2("picture2.jpg");
+        t2.file.set("property", 2)
+
+        TemplateList tList = TemplateList() << t1 << t2;
+
+        Gallery *gallery = Gallery::make("gallery_file.xml");
+        gallery->writeBlock(tList); // write the templatelist to disk
+
+<!--no italics*-->
+
+## void write(const [Template](../template/template.md) &t) {: #write }
+
+This is a pure virtual function. Write a single template to disk.
+
+* **function definition:**
+
+        virtual void write(const Template &t) = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    t | const [Template](../template/template.md) & | Template to write to disk
+
+* **output:** (void)
+* **example:**
+
+        Template t1("picture1.jpg");
+        t1.file.set("property", 1);
+        Template t2("picture2.jpg");
+        t2.file.set("property", 2)
+
+        Gallery *gallery = Gallery::make("gallery_file.xml");
+        gallery->write(t1); // write template1 to disk
+        gallery->write(t2); // write template2 to disk
+
+## qint64 totalSize() {: #totalsize }
+
+This is a virtual function. Get the total size of the gallery. Default implementation returns <tt>INT_MAX</tt>.
+
+* **function definition:**
+
+        virtual qint64 totalSize()
+
+* **parameters:** NONE
+* **output:** (qint64) Returns the total size of the gallery in bytes
+
+
+## qint64 position() {: #position }
+
+This is a virtual function. Get the current position of the read index in the gallery. The next call to [readBlock](#readblock) will read starting at the reported position.
+
+* **function output:**
+
+        virtual qint64 position()
+
+* **parameters:** NONE
+* **output:** (qint64) Returns the current read position in the gallery
+* **example:**
+
+        Gallery *gallery = Gallery::make("gallery_file.xml");
+
+        gallery->position(); // returns 0
+        bool done; gallery->readBlock(&done);
+        gallery->position(); // returns readBlockSize
+<!-- GALLERY -->
+
+Inherits [Object](../object/object.md)
+
+Plugin base class for storing a list of enrolled templates.
+
+See:
+
+* [Properties](properties.md)
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+A *gallery* is a file representing a [TemplateList](../templatelist/templatelist.md) serialized to disk. [File](../file/file.md)::[suffix](../file/functions.md#suffix) is used to determine which plugin should handle the gallery. The currently supported extensions are
+
+* xml
+* avi
+* wmv
+* mp4
+* webcam
+* vbb (OpenCV format)
+* txt
+* turk
+* template
+* stat
+* seq
+* post
+* mem (**NOTE:** Mem galleries live only in RAM; they should be used for caching and not for normal I/O)
+* matrix
+* landmarks
+* google
+* flat
+* FDDB
+* db
+* csv
+* crawl
+* gal
+* ut
+* url
+* json
+* arff
+
+Many of these extensions are unique to OpenBR. Please look at the relevant [Gallery plugin](../../../plugin_docs/gallery.md) for information on formatting and other concerns.
+Property | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=readblocksize></a>readBlockSize | int | Size in bytes of each block to be read
 \ No newline at end of file
+## [Gallery](gallery.md) \*make(const [File](../file/file.md) &file) {: #make }
+
+Make a [Gallery](gallery.md) from a string. The provided file is first split using [File](../file/file.md)::[split](../file/functions.md#split-1) and each resulting file is turned into a [Gallery](gallery.md) that is stored in a linked-list.
+
+* **function definition:**
+
+        static Gallery *make(const File &file)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    file | const [File](../file/file.md) & | File describing the gallery or galleries to construct
+
+* **output:** ([Gallery](gallery.md) \*) Returns a pointer to the first gallery in the linked list
+* **example:**
+
+        Gallery *gallery1 = Gallery::make("gallery_file.xml"); // returns a pointer to the gallery
+        Gallery *gallery2 = Gallery::make("gallery_file1.xml;gallery_file2.xml"); // returns a pointer to the gallery created with "gallery_file1.xml" with a pointer to the gallery created with "gallery_file2.xml"
+Constructor / Destructor | Description
+--- | ---
+virtual ~Initializer() | Virtual function. Default destructor.
+## void initialize() {: #initialize }
+
+This is a pure virtual function. It is called once at the end of [initialize](../context/statics.md#initialize). Any global initialization that needs to occur should occur within this function.
+
+* **function definition:**
+
+        virtual void initialize() const = 0
+
+* **parameters:** NONE
+* **output:** (void)
+
+## void finalize() {: #finalize }
+
+This is a virtual function. It is called once at the beginning of [finalize](../context/statics.md#finalize). Any global finalization should occur within this function. This includes deallocating anything that was allocated in [initialize](#initialize)
+
+* **function definition**:
+
+        virtual void finalize() const
+
+* **parameters:** NONE
+* **output:** (void)
+<!-- INITIALIZER -->
+
+Inherits [Object](../object/object.md)
+
+See:
+
+* [Constructors](constructors.md)
+* [Functions](functions.md)
+
+Plugin base class for initializing resources. On startup (the call to [Context](../context/context.md)::[initialize](../context/statics.md#initialize)), OpenBR will call [initialize](functions.md#initialize) on every Initializer that has been registered with the [Factory](../factory/factory.md). On shutdown (the call to [Context](../context/context.md)::[finalize](../context/statics.md#finalize), OpenBR will call [finalize](functions.md#finalize) on every registered initializer.
+
+The general use case for initializers is to launch shared contexts for third party integrations into OpenBR. These cannot be launched during [Transform](../transform/transform.md)::[init](../object/functions.md#init) for example, because multiple instances of the [Transform](../transform/transform.md) object could exist across multiple threads.
+## [QString][QString] toString(int row, int column) {: #tostring}
+
+Get a value in [data](members.md#data) as a string using a provided row and column index.
+
+* **function definition:**
+
+        QString toString(int row, int column) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    row | int | Row index of value
+    column | int | Column index of value
+
+* **output:** ([QString][QString]) Returns the value stored at (row, column) as a string
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target1.jpg") << Template("target2.jpg") << Template("target3.jpg");
+        TemplateList queries = TemplateList() << Template("query1.jpg") << Template("query2.jpg");
+
+        MatrixOutput *output = MatrixOutput::make(targets, queries);
+        output->set(10.0, 1, 2);
+        output->toString(1, 2); // Returns "10"
+        output->toString(2, 2); // ERROR: row index is out of range
+
+## void initialize(const [FileList](../filelist/filelist.md) &targetFiles, const [FileList](../filelist/filelist.md) &queryFiles) {: #initialize}
+
+Initialize the output. This function calls [initialize](../output/functions.md#initialize) which should be overloaded by derived classes that need to be initialized. After calling [initialize](../output/functions.md#initialize), [data](members.md#data) is initialized to be of size queryFiles.size() x targetFiles.size().
+
+* **function definition:**
+
+        void initialize(const FileList &targetFiles, const FileList &queryFiles)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetFiles | const [FileList](../filelist/filelist.md) & | List of target files for initialization
+    queryFiles | const [FileList](../filelist/filelist.md) & | List of query files for initialization
+
+* **output:** (void)
+
+
+## void set(float value, int i, int j) {: #set}
+
+Set a value in [data](members.md#data) at the provided row and column indices.
+
+* **function definition:**
+
+        void set(float value, int i, int j)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    value | float | Value to be set
+    i | int | Row index into [data](members.md#data)
+    j | int | Column index into [data](members.md#data)
+
+* **output:** (void)
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target1.jpg") << Template("target2.jpg") << Template("target3.jpg");
+        TemplateList queries = TemplateList() << Template("query1.jpg") << Template("query2.jpg");
+
+        MatrixOutput *output = MatrixOutput::make(targets, queries);
+        output->set(6.0, 0, 1);
+        output->toString(0, 1); // Returns "6.0"
+
+        output->set(10.0, 1, 2);
+        output->toString(1, 2); // Returns "10.0"
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+<!-- MATRIX OUTPUT -->
+
+Inherits from [Output](../output/output.md)
+
+See:
+
+* [Members](members.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+A special case output specifically for matrix data.
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=data></a>data | [Mat][Mat] | Matrix to store comparison data
+
+<!-- Links -->
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+## static [MatrixOutput](matrixoutput.md) \*make(const [FileList](../filelist/filelist.md) &targetFiles, const [FileList](../filelist/filelist.md) &queryFiles) {: #make}
+
+Make an [MatrixOutput](matrixoutput.md) from lists of target and query files. This function calls [Output](../output/output.md)::[make](../output/statics.md#make) using the string "Matrix". [Output](../output/output.md)::[make](../output/statics.md#make) in turn calls [initialize](functions.md#initialize). Initialize calls [initialize](../output/functions.md#initialize) which should be overloaded by derived classes to handle initialization.
+
+* **function definition:**
+
+        static MatrixOutput *make(const FileList &targetFiles, const FileList &queryFiles)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetFiles | const [FileList](../filelist/filelist.md) & | List of files representing the target templates
+    queryFiles | const [FileList](../filelist/filelist.md) & | List of files representing the query templates
+
+* **output:** ([MatrixOutput](matrixoutput.md) \*) Returns a pointer to the first output in the linked list
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target1.jpg") << Template("target2.jpg") << Template("target3.jpg");
+        TemplateList queries = TemplateList() << Template("query1.jpg") << Template("query2.jpg");
+
+        MatrixOutput *output = MatrixOutput::make(targets, queries); // returns a pointer to a MatrixOutput
+Constructor / Destructor | Description
+--- | ---
+MetadataTransform(bool trainable = true) | Construct a [MetadataTransform](metadatatransform.md). This constructor calls the [Transform](../transform/transform.md) [constructor](../transform/constructors.md) with the provided value for [trainable](../transform/members.md#trainable) and [independent](../transform/members.md#independent) set to false.
 \ No newline at end of file
+## void projectMetadata(const [File](../file/file.md) &src, [File](../file/file.md) &dst) {: #projectmetadata }
+
+This is a pure virtual function. It must be overloaded by all derived classes. Project a [Template's](../template/template.md) [metadata](../template/members.md#file) through the transform, modifying its contents in some way and storing the modified data in **dst**.
+
+* **function definition:**
+
+        virtual void projectMetadata(const File &src, File &dst) const = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [File](../file/file.md) & | Input File. It is immutable
+    dst | [File](../file/file.md) & | Output File. Should contain the modified data from the input template.
+
+* **output:** (void)
+* **example:**
+
+        class IncrementPropertyTransform : public MetadataTransform
+        {
+            Q_OBJECT
+            Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+            BR_PROPERTY(QString, key, "")
+
+            void projectMetadata(const File &src, File &dst) const
+            {
+                dst = src;
+                dst.set(key, src.get<int>(key, 0) + 1);
+            }
+        };
+
+        BR_REGISTER(Transform, IncrementPropertyTransform)
+
+        MetadataTransform *m_transform = (MetadataTransform *)Transform::make("IncrementProperty(property1)", NULL);
+
+        File in("picture.jpg"), out;
+        in.set("property1", 10);
+
+        m_transform->projectMetadata(in, out);
+        out.flat(); // Returns "picture.jpg[property1=11]"
+
+
+## void project(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #project }
+
+Project a [Template](../template/template.md) through the transform by passing its [metadata](../template/members.md#file) through [projectMetadata](#projectmetadata) and storing the result in dst. All matrices in src are passed unchanged to dst.
+
+* **function definition:**
+
+        void project(const Template &src, Template &dst) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | Input Template. It is immutable
+    dst | [Template](../template/template.md) & | Output Template. Should contain the modified data from the input template.
+
+* **output:** (void)
+<!-- METADATA TRANSFORM -->
+
+Inherits [Transform](../transform/transform.md)
+
+A [Transform](../transform/transform.md) that requires only [Template](../template/template.md) [metadata](../template/members.md#file)
+
+See:
+
+* [Constructors](constructors.md)
+* [Functions](functions.md)
+
+[MetadataTransforms](metadatatransform.md) are [Transforms](../transform/transform.md) that operate soley on textual [metadata](../template/members.md#file). They are *not* [independent](../transform/members.md#independent) because [Templates](../template/template.md) can only every have one collection of [metadata](../template/members.md#file).
+Constructor / Destructor | Description
+--- | ---
+MetaTransform() | Construct a [MetaTransform](metatransform.md). This constructor calls the [Transform](../transform/transform.md) [constructor](../transform/constructors.md) with [independent](../transform/members.md#independent) set to false.
+<!-- META TRANSFORM -->
+
+Inherits [Transform](../transform/transform.md)
+
+A [Transform](../transform/transform.md) that expect multiple matrices per [Template](../template/template.md)
+
+See:
+
+* [Constructors](constructors.md)
+
+[MetaTransforms](metatransform.md) are [Transforms](../transform/transform.md) that are not [independent](../transform/members.md#independent). This means they expect more then one matrix in each input [Template](../template/template.md) and a new instance of the transform should not be created for each matrix.
+
+## void init() {: #init }
+
+This is a virtual function. It is meant to be overloaded by derived classes if they need to initialize internal variables. The default constructor of derived objects should *never* be overloaded.
+
+* **function definition:**
+
+        virtual void init()
+
+* **parameters:** NONE
+* **output:** (void)
+
+---
+
+## void store([QDataStream][QDataStream] &stream) {: #store }
+
+This is a virtual function. Serialize an object to a [QDataStream][QDataStream]. The default implementation serializes each property and its value to disk.
+
+* **function definition:**
+
+        virtual void store(QDataStream &stream) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | Stream to store serialized data
+
+* **output:** (void)
+
+---
+
+## void load([QDataStream][QDataStream] &stream) {: #load }
+
+This is a virtual function. Deserialize an item from a [QDataStream][QDataStream]. Elements can be deserialized in the same order in which they were serialized. The default implementation deserializes a value for each property and then calls [init](#init).
+
+* **function definition:**
+
+        virtual void load(QDataStream &stream);
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | Stream to deserialize data from
+
+* **output:** (void)
+
+---
+
+## void serialize([QDataStream][QDataStream] &stream) {: #serialize }
+
+This is a virtual function. Serialize an entire plugin to a [QDataStream][QDataStream]. This function is larger in scope then [store](#store). It stores the string describing the plugin and then calls [store](#store) to serialize its parameters. This has the benefit of being able to deserialize an entire plugin (or series of plugins) from a stored model file.
+
+* **function definition:**
+
+        virtual void serialize(QDataStream &stream) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | Stream to store serialized data
+
+* **output:** (void)
+
+---
+
+## [QStringList][QStringList] parameters() {: #parameters }
+
+Get a string describing the parameters of the object
+
+* **function definition:**
+
+        QStringList parameters() const
+
+* **parameters:** NONE
+* **output:** ([QStringList][QStringList]) Returns a list of the parameters to a function
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1)
+            BR_PROPERTY(float, property2, 2.5)
+            BR_PROPERTY(QString, property3, "Value")
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        Factory<Transform>::make(".Example")->parameters(); // returns ["int property1 = 1", "float property2 = 2.5", "QString property3 = Value"]
+
+---
+
+## [QStringList][QStringList] prunedArguments(bool expanded = false) {: #prunedarguments }
+
+Get a string describing the user-specified parameters of the object. This means that parameters using their default value are not returned.
+
+* **function definition:**
+
+        QStringList prunedArguments(bool expanded = false) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    expanded | bool | (Optional) If true, expand all abbreviations or model files into their full description strings. Default is false.
+
+* **output:** ([QStringList][QStringList]) Returns a list of all of the user specified parameters of the object
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1)
+            BR_PROPERTY(float, property2, 2.5)
+            BR_PROPERTY(QString, property3, "Value")
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+
+        Factory<Transform>::make(".Example")->prunedArguments(); // returns []
+        Factory<Transform>::make(".Example(property1=10)")->prunedArguments(); // returns ["property1=10"]
+        Factory<Transform>::make(".Example(property1=10,property3=NewValue)")->prunedArguments(); // returns ["property1=10", "property3=NewValue"]
+
+---
+
+## [QString][QString] argument(int index, bool expanded) {: #argument }
+
+Get a string value of the argument at a provided index. An index of 0 returns the name of the object.
+
+* **function definition:**
+
+        QString argument(int index, bool expanded) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | Index of the parameter to look up
+    expanded | bool | If true, expand all abbreviations or model files into their full description strings.
+
+* **output:** ([QString][QString]) Returns a string value for the lookup argument
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1)
+            BR_PROPERTY(float, property2, 2.5)
+            BR_PROPERTY(QString, property3, "Value")
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        Factory<Transform>::make(".Example")->argument(0, false); // returns "Example"
+        Factory<Transform>::make(".Example")->argument(1, false); // returns "1"
+        Factory<Transform>::make(".Example")->argument(2, false); // returns "2.5"
+
+---
+
+## [QString][QString] description(bool expanded = false) {: #description }
+
+This is a virtual function. Get a description of the object. The description includes the name and any user-defined parameters of the object. Parameters that retain their default value are not included.
+
+* **function definition:**
+
+        virtual QString description(bool expanded = false) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    expanded | bool | (Optional) If true, expand all abbreviations or model files into their full description strings. Default is false.
+
+* **output:** ([QString][QString]) Returns a string describing the object
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1)
+            BR_PROPERTY(float, property2, 2.5)
+            BR_PROPERTY(QString, property3, "Value")
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        Factory<Transform>::make(".Example")->description(); // returns "Example"
+        qDebug() << Factory<Transform>::make(".Example(property3=NewValue)")->description(); // returns "Example(property3=NewValue)"
+
+---
+
+## void setProperty(const [QString][QString] &name, [QVariant][QVariant] value) {: #setproperty }
+
+Set a property with a provided name to a provided value. This function overloads [QObject][QObject]::setProperty so that it can handle OpenBR data types. If the provided name is not a property of the object nothing happens. If the provided name is a property but the provided value is not a valid type an error is thrown.
+
+* **function definition:**
+
+        void setProperty(const QString &name, QVariant value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    name | const [QString][QString] & | Name of the property to set
+    value | [QVariant][QVariant] | Value to set the property to
+
+* **output:** (void)
+* **see:** [setPropertyRecursive](#setpropertyrecursive), [setExistingProperty](#setexistingproperty)
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1)
+            BR_PROPERTY(float, property2, 2.5)
+            BR_PROPERTY(QString, property3, "Value")
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        QScopedPointer<Transform> transform(Factory<Transform>::make(".Example"));
+        transform->parameters(); // returns ["int property1 = 1", "float property2 = 2.5", "QString property3 = Value"]
+
+        transform->setProperty("property1", QVariant::fromValue<int>(10));
+        transform->parameters(); // returns ["int property1 = 10", "float property2 = 2.5", "QString property3 = Value"]
+
+        transform->setProperty("property1", QVariant::fromValue<QString>("Value")); // ERROR: incorrect type
+
+---
+
+## bool setPropertyRecursive(const [QString][QString] &name, [QVariant][QVariant] value) {: #setpropertyrecursive }
+
+Set a property of the object or the object's children to a provided value. The recursion is only single level; the children of the the objects children will not be affected. Only the first property found is set. This means that if a parent and a child have the same property only the parent's property is set.
+
+* **function definition:**
+
+        virtual bool setPropertyRecursive(const QString &name, QVariant value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    name | const [QString][QString] & | Name of the property to set
+    value | [QVariant][QVariant] | Value to set the property to
+
+* **output:** (bool) Returns true if the property is set in either the object or its children
+* **see:** [setProperty](#setproperty), [setExistingProperty](#setexistingproperty), [getChildren](#getchildren-2)
+* **example:**
+
+        class ChildTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            BR_PROPERTY(int, property1, 2)
+            BR_PROPERTY(int, property2, 2.5)
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ChildTransform)
+
+        class ParentTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(br::Transform *child READ get_child WRITE set_child RESET reset_child STORED false)
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            BR_PROPERTY(br::Transform*, child, Factory<Transform>::make(".Child"))
+            BR_PROPERTY(int, property1, 1)
+
+            ...
+        };
+
+        QScopedPointer<Transform> parent(Factory<Transform>::make(".Parent"));
+        parent->parameters(); // returns ["br::Transform* child = ", "int property1 = 1"]
+        parent->getChildren<Transform>().first()->parameters(); // returns ["int property1 = 2", "float property2 = 2"]
+
+        parent->setPropertyRecursive("property1", QVariant::fromValue<int>(10));
+        parent->parameters(); // returns ["br::Transform* child = ", "int property1 = 10"]
+        parent->getChildren<Transform>().first()->parameters(); // returns ["int property1 = 2", "float property2 = 2"]
+
+        parent->setPropertyRecursive("property2", QVariant::fromValue<float>(10.5));
+        parent->parameters(); // returns ["br::Transform* child = ", "int property1 = 10"]
+        parent->getChildren<Transform>().first()->parameters(); // returns ["int property1 = 2", "float property2 = 10"]
+
+---
+
+## bool setExistingProperty(const [QString][QString] &name, [QVariant][QVariant] value) {: #setexistingproperty }
+
+Attempt to set a property to a provided value. If the provided value is not a valid type for the given property an error is thrown.
+
+* **function definition:**
+
+        bool setExistingProperty(const QString &name, QVariant value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    name | const [QString][QString] & | Name of the property to set
+    value | [QVariant][QVariant] | Value to set the property to
+
+* **output:** (bool) Returns true if the provided property exists and can be set to the provided value, otherwise returns false
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            BR_PROPERTY(int, property1, 2)
+            BR_PROPERTY(int, property2, 2.5)
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        QScopedPointer<Transform> transform(Factory<Transform>::make(".Child"));
+        transform->setExistingProperty("property1", QVariant::fromValue<int>(10)); // returns true
+        transform->parameters(); // returns ["int property1 = 10", "float property2 = 2"]
+
+        transform->setExistingProperty("property3", QVariant::fromValue<int>(10)); // returns false
+        transform->setExistingProperty("property1", QVariant::fromValue<QString>("Hello")); // ERROR: incorrect type
+
+---
+
+## [QList][QList]&lt;[Object](object.md) \*&gt; getChildren() {: #getchildren-1 }
+
+This is a virtual function. Get all of the children of the object. The default implementation looks for children in the properties of the object. A derived object should overload this function if it needs to provide children from a different source.
+
+* **function definition:**
+
+        virtual QList<Object *> getChildren() const
+
+<!-- no italics* -->
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;[Object](object.md) \*&gt;) Returns a list of all of the children of the object
+* **example:**
+
+        class ChildTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            BR_PROPERTY(int, property1, 2)
+            BR_PROPERTY(int, property2, 2.5)
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ChildTransform)
+
+        class ParentTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(br::Transform *child READ get_child WRITE set_child RESET reset_child STORED false)
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            BR_PROPERTY(br::Transform *, child, Factory<Transform>::make(".Child"))
+            BR_PROPERTY(int, property1, 1)
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ParentTransform)
+
+        QScopedPointer<Transform> transform(Factory<Transform>::make(".Parent"));
+        transform->getChildren(); // returns [br::ChildTransform(0x7fc10bf01050, name = "Child")]
+        transform->getChildren().first()->parameters(); // returns ["int property1 = 2", "float property2 = 2"]
+
+---
+
+## [QList][QList]&lt;T \*&gt; getChildren() {: #getchildren-2 }
+
+Provides a wrapper on [getChildren](#getchildren-1) as a convenience to allow the return type (<tt>T</tt>) to be specified. <tt>T</tt> must be a derived class of [Object](object.md).
+
+* **function definition:**
+
+        template<typename T>
+        QList<T *> getChildren() const
+
+* **parameters:** NONE
+* **output:** ([QList][QList]&lt;<tt>T</tt> \*&gt;) Returns a list of all of the children of the object, casted to type <tt>T</tt>. <tt>T</tt> must be a derived class of [Object](object.md)
+* **example:**
+
+        class ChildTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            BR_PROPERTY(int, property1, 2)
+            BR_PROPERTY(int, property2, 2.5)
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ChildTransform)
+
+        class ParentTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(br::Transform *child READ get_child WRITE set_child RESET reset_child STORED false)
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            BR_PROPERTY(br::Transform *, child, Factory<Transform>::make(".Child"))
+            BR_PROPERTY(int, property1, 1)
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ParentTransform)
+
+        QScopedPointer<Transform> transform(Factory<Transform>::make(".Parent"));
+        transform->getChildren<Transform>(); // returns [br::ChildTransform(0x7fc10bf01050, name = "Child")]
+        transform->getChildren<Transform>().first()->parameters(); // returns ["int property1 = 2", "float property2 = 2"]
+
+<!-- Links -->
+[QDataStream]: http://doc.qt.io/qt-5/qdatastream.html "QDataStream"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+## BR_PROPERTY {: #br_property }
+
+This macro provides an extension to the [Qt Property System][Qt Property System]. It's purpose is to set default values for each property in an object. Every call to <tt>BR_PROPERTY</tt> should have a corresponding call to <tt>Q_PROPERTY</tt>.
+
+* **macro definition:**
+
+        #define BR_PROPERTY(TYPE,NAME,DEFAULT)
+
+* **parameters:**
+
+    Parameter | Description
+    --- | ---
+    TYPE | The type of the property (int, float etc.)
+    NAME | The name of the property
+    DEFAULT | The default value of the property
+
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property1 READ get_property1 WRITE set_property1 RESET reset_property1 STORED false)
+            Q_PROPERTY(float property2 READ get_property2 WRITE set_property2 RESET reset_property2 STORED false)
+            Q_PROPERTY(QString property3 READ get_property3 WRITE set_property3 RESET reset_property3 STORED false)
+            BR_PROPERTY(int, property1, 1) // sets default value of "property1" to 1
+            BR_PROPERTY(float, property2, 2.5) // sets default value of "property2" to 2.5
+            BR_PROPERTY(QString, property3, "Value") // sets default value of "property3" to "Value"
+
+            ...
+        };
+
+<!-- Links -->
+[Qt Property System]: http://doc.qt.io/qt-5/properties.html "Qt Property System"
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id="file"></a>file | [File](../file/file.md) | The [File](../file/file.md) used to construct the plugin.
+<a class="table-anchor" id="firstavailablepropertyidx"></a>firstAvailablePropertyIdx | int | Index of the first property of the object that can be set via command line arguments
 \ No newline at end of file
+<!-- OBJECT -->
+
+Inherits from [QObject][QObject]
+
+See:
+
+* [Members](members.md)
+* [Macros](macros.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+This is the base class of all OpenBR plugins. [Objects](object.md) are constructed from [Files](../file/file.md). The [File's](../file/file.md) [name](../file/members.md#name) specifies which plugin to construct and the [File's](../file/file.md) [metadata](../file/members.md#m_metadata) provides initialization values for the plugin's properties.
+
+<!-- Links -->
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+## [QStringList][QStringList] parse(const [QString][QString] &string, char split = ',') {: #parse }
+
+Split the provided string using the provided split character. Lexical scoping of <tt>()</tt>, <tt>[]</tt>, <tt>\<\></tt>, and <tt>{}</tt> is respected.
+
+* **function definition:**
+
+        static QStringList parse(const QString &string, char split = ',');
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    string | const [QString][QString] & | String to be split
+    split | char | (Optional) The character to split the string on. Default is ','
+
+* **output:** ([QStringList][QStringList]) Returns a list of the split strings
+* **example:**
+
+        Object::parse("Transform1(p1=v1,p2=v2),Transform2(p1=v3,p2=v4)"); // returns ["Transform1(p1=v1,p2=v2)", "Transform2(p1=v3,p2=v4)"]
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QStringList]: http://doc.qt.io/qt-5/qstringlist.html "QStringList"
+Constructor / Destructor | Description
+--- | ---
+virtual ~Output() | Default Destructor. Derived classes should overload this to handle serialization to disk.
+## void initialize(const [FileList](../filelist/filelist.md) &targetFiles, const [FileList](../filelist/filelist.md) &queryFiles) {: #initialize }
+
+This is a virtual function. Initialize the output with provided target and query files.
+
+* **function definition:**
+
+        virtual void initialize(const [FileList](../filelist/filelist.md) &targetFiles, const [FileList](../filelist/filelist.md) &queryFiles)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    targetFiles | const [FileList](../filelist/filelist.md) & | Target files to initialize the Output with
+    queryFiles | const [FileList](../filelist/filelist.md) & | Query files to initialize the Output with
+
+* **output:** (void)
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target1.jpg") << Template("target2.jpg") << Template("target3.jpg");
+        TemplateList queries = TemplateList() << Template("query1.jpg") << Template("query2.jpg");
+
+        Output *output = Factory::make<Output>("output.mtx");
+        output->initialize(targets, queries); // This is the same as calling Output::make("output.mtx", targets, queries)
+
+## void setBlock(int rowBlock, int columnBlock) {: #setblock }
+
+This is a virtual function. Set the read offset of the Output.
+
+* **function definition:**
+
+        virtual void setBlock(int rowBlock, int columnBlock)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    rowBlock | int | Row position of the offset
+    columnBlock | int | Column position of the offset
+
+* **output:** (void)
+
+## void setRelative(float value, int i, int j) {: #setrelative }
+
+This is a virtual function. Set a value in the Output. **i** and **j** are *relative* to the current block.
+
+* **function definition:**
+
+        virtual void setRelative(float value, int i, int j)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    value | float | Value to set in the output
+    i | int | Row value relative to the current block
+    j | int | Column value relative to the current block
+
+* **output:** (void)
+
+
+## void set(float value, int i, int j) {: #set }
+
+This is a pure virtual function. Set a value in the output.
+
+* **function definition:**
+
+        virtual void set(float value, int i, int j) = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    value | float | Value to be inserted into the output
+    i | int | Row index to insert at
+    j | int | Column index to insert at
+
+* **output:** (void)
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=targetfiles></a>targetFiles | [FileList](../filelist/filelist.md) | List of files representing the target templates
+<a class="table-anchor" id=queryfiles></a>queryFiles | [FileList](../filelist/filelist.md) | List of files representing the query templates
+<a class="table-anchor" id=selfsimilar></a>selfSimilar | bool | True if targetFiles == queryFiles, false otherwise
+<!-- OUTPUT -->
+
+Inherits from [Object](../object/object.md)
+
+Plugin base class for storing template comparison results.
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+An *Output* is a [File](../file/file.md) representing the result comparing templates. [File](../file/file.md)::[suffix](../file/functions.md#suffix) is used to determine which plugin should handle the output. The currently supported extensions are:
+
+* txt
+* tail
+* rr
+* rank
+* null
+* mtx
+* melt
+* hist
+* heat
+* eval
+* csv
+* best
+
+Many of these extensions are unique to OpenBR. Please look at the relevant [Output plugin](../../../plugin_docs/output.md) for information on formatting and other concerns.
+Property | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=blockrows></a>blockRows | int | Row count for incremental writing block
+<a class="table-anchor" id=blockcols></a>blockCols | int | Column count for incremental writing block
 \ No newline at end of file
+## Output \*make(const [File](../file/file.md) &file, const [FileList](../filelist/filelist.md) &targetFiles, const [FileList](../filelist/filelist.md) &queryFiles) {: #make}
+
+Make an [Output](output.md) from a string and lists of target and query files. This function calls [initialize](functions.md#initialize), which should be overloaded by derived classes to handle initialization. The provided file is first split using [File](../file/file.md)::[split](../file/functions.md#split-1) and each resulting file is turned into an [Output](output.md) that is stored in a linked-list.
+
+* **function definition:**
+
+        static Output *make(const File &file, const FileList &targetFiles, const FileList &queryFiles)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    file | const [File](../file/file.md) & | File describing the output or outputs to construct
+    targetFiles | const [FileList](../filelist/filelist.md) & | List of files representing the target templates
+    queryFiles | const [FileList](../filelist/filelist.md) & | List of files representing the query templates
+
+* **output:** ([Output](output.md) \*) Returns a pointer to the first output in the linked list
+* **example:**
+
+        TemplateList targets = TemplateList() << Template("target1.jpg") << Template("target2.jpg") << Template("target3.jpg");
+        TemplateList queries = TemplateList() << Template("query1.jpg") << Template("query2.jpg");
+
+        Output *output1 = Output::make("output.mtx", targets, queries); // returns a pointer to an Output at "output.mtx"
+        Output *output2 = Output::make("output1.mtx;output2.mtx", targets, queries); // returns a pointer to the output created with "output1.mtx" with a pointer to the output created with "output2.mtx"
+Constructor / Destructor | Description
+--- | ---
+virtual ~Representation() | Default destructor. It doesn' do anything.
+## [Mat][Mat] preprocess(const [Mat][Mat] &image) {: #preprocess }
+
+This is a virtual function. Preprocess an image into the desired format for the representation. Default implementation returns the image unmodified.
+
+* **function definition:**
+
+        virtual Mat preprocess(const Mat &image) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    image | const [Mat][Mat] & | Image to be preprocessed
+
+* **output:** ([Mat][Mat]) Returns the preprocessed image
+* **example:**
+
+        Template in("picture.jpg");
+
+        Representation *rep = Representation::make("RepresentationThatRequiresGrayscale");
+        rep->preprocess(in); // returns the original image converted to grayscale
+
+## void train(const [QList][QList]&lt;[Mat][Mat]&gt; &images, const [QList][QList]&lt;float&gt; &labels) {: #train }
+
+This is a virtual function. Train the representation using the provided images and associated labels. Default implementation does no training.
+
+* **function definition:**
+
+        virtual void train(const QList<Mat> &images, const QList<float> &labels)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    images | const [QList][QList]&lt;[Mat][Mat]&gt; & | Training images
+    labels | const [QList][QList]&lt;float&gt; & | Training labels
+
+* **output:** (void)
+* **example:**
+
+        // Create data for a 2-class classification problem
+        QList<Mat> images = QList<Mat>() << Template("training_pic1.jpg").m()
+                                         << Template("training_pic2.jpg").m()
+                                         << Template("training_pic3.jpg").m()
+                                         << Template("training_pic4.jpg").m();
+
+        QList<float> labels = QList<float>() << 0 << 0 << 1 << 1;
+
+        Representation *rep = Representation::make("Representation");
+        rep->train(images, labels);
+
+## [Mat][Mat] evaluate(const [Mat][Mat] &image, const [QList][QList]&lt;int&gt; &indices = [QList][QList]&lt;int&gt;()) {: #evaluate }
+
+This is a pure virtual function. For a provided input image calculate only the feature responses associated with the provided indices. The indices are expected relative to the entire feature space. If the indices list is empty the response of the entire feature space is calculated.
+
+* **function definition:**
+
+        virtual cv::Mat evaluate(const Mat &image, const QList<int> &indices = QList<int>()) const = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    image | const [Mat][Mat] & | The image to be converted
+    indices | const [QList][QList]&lt;int&gt; & | (Optional) A list of indices corresponding to the desired features to calculate. If the list is empty all features are calculated.
+
+* **output:** ([Mat][Mat]) Returns a 1xN feature vector where N is the number of indices provided. If no indices are provided N equals the size of the feature space.
+* **example:**
+
+        Template image("picture.jpg");
+
+        Representation *rep = Representation::make("Representation");
+        rep->evaluate(image, QList<int>() << 7 << 10 << 72 ); // returns a 1x3 Mat feature vector
+
+## int numFeatures() {: #numfeatures }
+
+This is a pure virtual function. Get the size of the feature space.
+
+* **function definition:**
+
+        virtual int numFeatures() const = 0
+
+* **parameters:** NONE
+* **output:** (int) Returns the size of the feature space
+* **example:**
+
+        Representation *rep1 = Representation::make("RepresentationWith1000features");
+        Representation *rep2 = Representation::make("RepresentationWith25643features");
+
+        rep1->numFeatures(); // returns 1000
+        rep2->numFeatures(); // returns 25643
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+<!-- REPRESENTATION -->
+
+Inherits [Object](../object/object.md).
+
+Plugin base class for converting images into feature vectors
+
+See:
+
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+[Representations](representation.md) are used to convert images to feature vectors lazily (only when necessary). They are similar to [Transforms](../transform/transform.md) in many respects but differ in a few key areas. [Transforms](../transform/transform.md) should be used to construct feature vectors if it is desirable to construct a vector before evaluation that encompasses the entire feature space (or a smaller subset learned during training). [Representations](representation.md) should be used if their is a large *possible* feature space but a few select features are necessary for a particular computation. This is often the case in tree architectures, where each node has an associated feature. The *possible* feature space is all of the features associated with all of the nodes, but the *required* features are only the features associated with nodes that are actually visited. The purpose of [Representations](representation.md) is to allow these features to be calculated as needed instead of calculating all of the features before hand, which is less efficient.
+## [Representation](representation.md) \*make([QString][QString] str, [QObject][QObject] \*parent) {: #make }
+
+Make a [Representation](representation.md) from a string. The string is passed to [Factory](../factory/factory.md)::[make](../factory/statics.md#make) to be turned into a representation.
+
+* **function definition:**
+
+        static Representation *make(QString str, QObject *parent)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    str | [QString][QString] | String describing the representation
+    parent | [QObject][QObject] \* | Parent of the object to be created
+
+* **output:** ([Representation](representation.md) \*) Returns a pointer to the [Representation](representation.md) described by the string
+* **see:** [Factory::make](../factory/statics.md#make)
+* **example:**
+
+        Representation *rep = Representation::make("Representation(property1=value1)");
+        rep->description(); // Returns "Representation(property1=value1)"
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+Constructor | Description
+--- | ---
+Template() | The default template constructor. It doesn't do anything.
+Template(const [File](../file/file.md) &file) | Sets [file](members.md#file) to the given [File](../file/file.md).
+Template(const [File](../file/file.md) &file, const [Mat][Mat] &mat) | Sets [file](members.md#file) to the given [File](../file/file.md) and appends the given [Mat][Mat] to itself.
+Template(const [Mat][Mat] &mat) | Appends the given [Mat][Mat] to itself
+
+<!-- Links -->
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+## operator const [File](../file/file.md) &() const {: #operator-file }
+
+Idiom to treat the template like a [File](../file/file.md).
+
+* **function definition:**
+
+        inline operator const File &() const
+
+* **parameters:** NONE
+* **output:** ([File](../file/file.md) Returns [file](members.md#file).
+
+
+## const [Mat][Mat] &m() const {: #m-1 }
+
+Idiom to treat the template like a [Mat][Mat].
+
+* **function definition:**
+
+        inline const Mat &m() const
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **example:**
+
+        Template t;
+        t.m(); // returns empty mat
+
+        Mat m1;
+        t.append(m1);
+        t.m(); // returns m1;
+
+        Mat m2;
+        t.append(m2);
+        t.m(); // returns m2;
+
+
+## [Mat][Mat] &m() {: #m-2 }
+
+Idiom to treat the template like a [Mat][Mat].
+
+* **function definition:**
+
+        inline Mat &m()
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **example:**
+
+        Template t;
+        t.m(); // returns empty mat
+
+        Mat m1;
+        t.append(m1);
+        t.m(); // returns m1;
+
+        Mat m2;
+        t.append(m2);
+        t.m(); // returns m2;
+
+
+## operator const [Mat][Mat] &() {: #operator-mat-1 }
+
+Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#m-1).
+
+* **function definition:**
+
+        inline operator const Mat&() const
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#m-1)
+
+
+## operator [Mat][Mat] &() {: #operator-mat-2 }
+
+Idiom to treat the template like a [Mat][Mat]. Makes a call to [m()](#m-1).
+
+* **function definition:**
+
+        inline operator Mat&()
+
+* **parameters:** NONE
+* **output:** ([Mat][Mat]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#m-1)
+
+
+## operator [_InputArray][InputArray] &() {: #operator-inputarray }
+
+Idiom to treat the template like an [_InputArray][InputArray]. Makes a call to [m()](#m-1).
+
+* **function definition:**
+
+        inline operator _InputArray() const
+
+<!-- _no italics_-->
+* **parameters:** NONE
+* **output:** ([_InputArray][InputArray]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#m-1)
+
+
+## operator [_OutputArray][OutputArray] &() {: #operator-outputarray }
+
+Idiom to treat the template like an [_OutputArray][InputArray]. Makes a call to [m()](#m-1).
+
+* **function definition:**
+
+        inline operator _OutputArray()
+
+* **parameters:** NONE
+* **output:** ([_OutputArray][OutputArray]) Returns the last [Mat][Mat] in the list. If the list is empty an empty [Mat][Mat] is returned.
+* **see:** [m](#m-1)
+
+
+## [Mat][Mat] &operator =(const [Mat][Mat] &other) {: #operator-e }
+
+Idiom to treat the template like a [Mat][Mat]. Set the result of [m()](#m-1) equal to other.
+
+* **function definition:**
+
+        inline Mat &operator=(const Mat &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const Mat & | Mat to overwrite value of [m](#m-1)
+
+* **output**: ([Mat][Mat] &) Returns a reference to the updated [Mat][Mat]
+
+
+## bool isNull() const {: #isnull }
+
+Check if the template is NULL.
+
+* **function definition:**
+
+        inline bool isNull() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if the template is empty *or* if [m](#m-1) has no data.
+* **example:**
+
+        Template t;
+        t.isNull(); // returns true
+
+        t.append(Mat());
+        t.isNull(); // returns true
+
+        t.append(Mat::ones(1, 1, CV_8U));
+        t.isNull(); // returns false
+
+
+## void merge(const [Template](template.md) &other) {: #merge }
+
+Append the contents of another template. The [files](members.md#file) are appended using [append](../file/functions.md#append-1).
+
+* **function definition:**
+
+        inline void merge(const Template &other)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    other | const [Template](template.md) & | Template to be merged
+
+* **output:** (void)
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+        Mat m1, m2;
+
+        t1.append(m1);
+        t2.append(m2);
+
+        t1.merge(t2);
+
+        t1.file; // returns picture1.jpg;picture2.jpg[seperator=;]
+        t1; // returns [m1, m2]
+
+
+## size_t bytes() const {: #bytes }
+
+Get the total number of bytes in the template
+
+* **function definition:**
+
+        size_t bytes() const
+
+* **parameters:** None
+* **output:** (int) Returns the sum of the bytes in each [Mat][Mat] in the [Template](template.md)
+* **example:**
+
+        Template t;
+
+        Mat m1 = Mat::ones(1, 1, CV_8U); // 1 byte
+        Mat m2 = Mat::ones(2, 2, CV_8U); // 4 bytes
+        Mat m3 = Mat::ones(3, 3, CV_8U); // 9 bytes
+
+        t << m1 << m2 << m3;
+
+        t.bytes(); // returns 14
+
+
+## Template clone() const {: #clone }
+
+Clone the template
+
+* **function definition:**
+
+        Template clone() const
+
+* **parameters:** NONE
+* **output:** ([Template](template.md)) Returns a new [Template](template.md) with copies of the [file](members.md#file) and each [Mat][Mat] that was in the original.
+* **example:**
+
+        Template t1("picture.jpg");
+        t1.append(Mat::ones(1, 1, CV_8U));
+
+        Template t2 = t1.clone();
+
+        t2.file; // returns "picture.jpg"
+        t2; // returns ["1"]
+
+<!-- Links -->
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+[InputArray]: http://docs.opencv.org/modules/core/doc/basic_structures.html#inputarray "InputArray"
+[OutputArray]: http://docs.opencv.org/modules/core/doc/basic_structures.html#outputarray "OutputArray"
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=file></a>file | [File](../file/file.md) | The file that constructs the template and stores its associated metadata
+## [QDataStream][QDataStream] &operator<<([QDataStream][QDataStream] &stream, const [Template](template.md) &t) {: #operator-ltlt }
+
+Serialize a template
+
+* **function definition:**
+
+        QDataStream &operator<<(QDataStream &stream, const Template &t)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | The stream to serialize to
+    t | const [Template](template.md) & | The template to serialize
+
+* **output:** ([QDataStream][QDataStream] &) Returns the updated stream
+* **example:**
+
+        void store(QDataStream &stream)
+        {
+            Template t("picture.jpg");
+            t.append(Mat::ones(1, 1, CV_8U));
+
+            stream << t; // "["1"]picture.jpg" serialized to the stream
+        }
+
+## [QDataStream][QDataStream] &operator>>([QDataStream][QDataStream] &stream, [Template](template.md) &t) {: #operator-gtgt }
+
+Deserialize a template
+
+* **function definition:**
+
+        QDataStream &operator>>(QDataStream &stream, Template &t)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | The stream to deserialize to
+    t | const [Template](template.md) & | The template to deserialize
+
+* **output:** ([QDataStream][QDataStream] &) Returns the updated stream
+* **example:**
+
+        void load(QDataStream &stream)
+        {
+            Template in("picture.jpg");
+            in.append(Mat::ones(1, 1, CV_8U));
+
+            stream << in; // "["1"]picture.jpg" serialized to the stream
+
+            Template out;
+            stream >> out;
+
+            out.file; // returns "picture.jpg"
+            out; // returns ["1"]
+        }
+
+<!-- Links -->
+[QDataStream]: http://doc.qt.io/qt-5/qdatastream.html "QDataStream"
+<!-- TEMPLATE -->
+
+Inherits [QList][QList]&lt;[Mat][Mat]&gt;.
+
+A list of matrices associated with a file.
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+The Template is one of two important data structures in OpenBR (the [File](../file/file.md) is the other).
+A template represents a biometric at various stages of enrollment and can be modified by [Transforms](../transform/transform.md) and compared to other [templates](template.md) with [Distances](../distance/distance.md).
+
+While there exist many cases (ex. video enrollment, multiple face detects, per-patch subspace learning, ...) where the template will contain more than one matrix,
+in most cases templates have exactly one matrix in their list representing a single image at various stages of enrollment.
+In the cases where exactly one image is expected, the template provides the function m() as an idiom for treating it as a single matrix.
+Casting operators are also provided to pass the template into image processing functions expecting matrices.
+
+Metadata related to the template that is computed during enrollment (ex. bounding boxes, eye locations, quality metrics, ...) should be assigned to the template's [File](members.md#file) member.
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+Constructor | Description
+--- | ---
+TemplateList() | The default [TemplateList](templatelist.md) constructor. Doesn't do anything.
+TemplateList(const [QList][QList]&lt;[Template](../template/template.md)&gt; &templates) | Initialize the [TemplateList](templatelist.md) with a list of templates. The given list is appended
+TemplateList(const [QList][QList]&lt;[File](../file/file.md)&gt; &files) | Initialize the [TemplateList](templatelist.md) with a list of [Files](../file/file.md). Each [File](../file/file.md) is treated like a template and appended.
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+## [QList][QList]&lt;int&gt; indexProperty(const [QString][QString] &propName, [QHash][QHash]&lt;[QString][QString], int&gt; &valueMap, [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; &reverseLookup) const {: #indexproperty-1 }
+
+Convert [metadata](../file/members.md#m_metadata) values associated with **propName** to integers. Each unique value gets its own integer. This is useful in many classification problems where nominal data (e.g "Male", "Female") needs to represented with integers ("Male" = 0, "Female" = 1). **valueMap** and **reverseLookup** are created to allow easy conversion to the integer replacements and back.
+
+* **function definition:**
+
+        QList<int> indexProperty(const QString &propName, QHash<QString, int> &valueMap, QHash<int, QVariant> &reverseLookup) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](../file/members.md#m_metadata) key
+    valueMap | [QHash][QHash]&lt;[QString][QString], int&gt; & | A mapping from [metadata](../file/members.md#m_metadata) values to the equivalent unique index. [QStrings][QString] are used instead of [QVariant][QVariant] so comparison operators can be used. This is filled in by the function and can be provided empty.
+    reverseLookup | [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; & | A mapping from the unique index to the original value. This is the *reverse* mapping of the **valueMap**. This is filled in by the function and can be provided empty.
+
+* **output:** ([QList][QList]&lt;int&gt;) Returns a list of unique integers that can be mapped to the [metadata](../file/members.md#m_metadata) values associated with **propName**. The integers can be mapped to their respective values using **valueMap** and the values can be mapped to the integers using **reverseLookup**.
+* **example:**
+
+        Template t1, t2, t3, t4;
+
+        t1.file.set("Key", QString("Class 1"));
+        t2.file.set("Key", QString("Class 2"));
+        t3.file.set("Key", QString("Class 3"));
+        t4.file.set("Key", QString("Class 1"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+
+        QHash<QString, int> valueMap;
+        QHash<int, QVariant> reverseLookup;
+        tList.indexProperty("Key", valueMap, reverseLookup); // returns [0, 1, 2, 0]
+        valueMap; // returns QHash(("Class 1", 0)("Class 2", 1)("Class 3", 2))
+        reverseLookup; // QHash((0, QVariant(QString, "Class 1")) (2, QVariant(QString, "Class 3")) (1, QVariant(QString, "Class 2")))  
+
+
+## [QList][QList]&lt;int&gt; indexProperty(const [QString][QString] &propName, [QHash][QHash]&lt;[QString][QString], int&gt; \*valueMap=NULL, [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; \*reverseLookup=NULL) const {: #indexproperty-2 }
+
+Shortcut to call [indexProperty](#indexproperty-1) without **valueMap** or **reverseLookup** arguments.
+
+* **function definition:**
+
+        QList<int> indexProperty(const QString &propName, QHash<QString, int> * valueMap=NULL,QHash<int, QVariant> * reverseLookup = NULL) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](../file/members.md#m_metadata) key
+    valueMap | [QHash][QHash]&lt;[QString][QString], int&gt; \* | (Optional) A mapping from [metadata](../file/members.md#m_metadata) values to the equivalent unique index. [QStrings][QString] are used instead of [QVariant][QVariant] so comparison operators can be used. This is filled in by the function and can be provided empty.
+    reverseLookup | [QHash][QHash]&lt;int, [QVariant][QVariant]&gt; \* | (Optional) A mapping from the unique index to the original value. This is the *reverse* mapping of the **valueMap**. This is filled in by the function and can be provided empty.
+
+* **output:** ([QList][QList]&lt;int&gt;) Returns a list of unique integers that can be mapped to the [metadata](../file/members.md#m_metadata) values associated with **propName**. The integers can be mapped to their respective values using **valueMap** (if provided) and the values can be mapped to the integers using **reverseLookup** (if provided).
+
+
+## [QList][QList]&lt;int&gt; applyIndex(const [QString][QString] &propName, const [QHash][QHash]&lt;[QString][QString], int&gt; &valueMap) const {: #applyindex }
+
+Apply a mapping to convert non-integer values to integers. [Metadata](../file/members.md#m_metadata) values associated with **propName** are mapped through the given **valueMap**.
+
+* **function definition:**
+
+        QList<int> applyIndex(const QString &propName, const QHash<QString, int> &valueMap) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](../file/members.md#m_metadata) key
+    valueMap | const [QHash][QHash]&lt;[QString][QString], int&gt; & | (Optional) A mapping from [metadata](../file/members.md#m_metadata) values to the equivalent unique index. [QStrings][QString] are used instead of [QVariant][QVariant] so comparison operators can be used.
+
+* **output:** ([Qlist][QList]&lt;int&gt;) Returns a list of integer values. The values are ordered in the same order as the [Templates](../template/template.md) in the list. The values are calculated like so:
+
+    1. If the value *is* found in the **valueMap**, its integer mapping is appened to the list.
+    2. If the value *is not* found in the **valueMap**, -1 is appened to the list.
+
+* **example:**
+
+        Template t1, t2, t3, t4;
+
+        t1.file.set("Key", QString("Class 1"));
+        t2.file.set("Key", QString("Class 2"));
+        t3.file.set("Key", QString("Class 3"));
+        t4.file.set("Key", QString("Class 1"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+
+        QHash<QString, int> valueMap;
+        valueMap.insert("Class 1", 0);
+        valueMap.insert("Class 2", 1);
+
+        tList.applyIndex("Key", valueMap); // returns [0, 1, -1, 0]
+
+
+## <tt>T</tt> bytes() const {: #bytes }
+
+Get the total number of bytes in the [TemplateList](templatelist.md).
+
+* **function definition:**
+
+        template <typename T> T bytes() const
+
+* **parameters:** NONE
+* **output:** (<tt>T</tt>) Returns the sum of the bytes in each of the [Templates](../template/template.md) in the list. <tt>T</tt> is a user specified type. It is expected to be numeric (int, float etc.)
+* **see:** [bytes](../template/functions.md#bytes)
+* **example:**
+
+        Template t1, t2;
+
+        t1.append(Mat::ones(1, 1, CV_8U)); // 1 byte
+        t1.append(Mat::ones(2, 2, CV_8U)); // 4 bytes
+        t2.append(Mat::ones(3, 3, CV_8U)); // 9 bytes
+        t2.append(Mat::ones(4, 4, CV_8U)); // 16 bytes
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+        tList.bytes(); // returns 30
+
+
+## [QList][QList]&lt;[Mat][Mat]&gt; data(int index = 0) const {: #data }
+
+Get a list of matrices compiled from each [Template](../template/template.md) in the list.
+
+* **function definition:**
+
+        QList<cv::Mat> data(int index = 0) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    index | int | (Optional) Index into each [Template](../template/template.md) to select a [Mat][Mat]. Default is 0.
+
+* **output:** ([QList][QList]&lt;[Mat][Mat]&gt;) Returns a list of [Mats][Mat]. One [Mat][Mat] is supplied by each [Template](../template/template.md) in the image at the specified index.
+* **example:**
+
+        Template t1, t2;
+
+        t1.append(Mat::ones(1, 1, CV_8U));
+        t1.append(Mat::zeros(1, 1, CV_8U));
+        t2.append(Mat::ones(1, 1, CV_8U));
+        t2.append(Mat::zeros(1, 1, CV_8U));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+        tList.data(); // returns ["1", "1"];
+        tList.data(1); // returns ["0", "0"];
+
+
+## [QList][QList]&lt;[TemplateList](templatelist.md)&gt; partition(const [QList][QList]&lt;int&gt; &partitionSizes) const {: #partition }
+
+Divide the [TemplateList](templatelist.md) into a list of [TemplateLists](templatelist.md) partitions.
+
+ * **function defintion:**
+
+        QList<TemplateList> partition(const QList<int> &partitionSizes) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    partitionSizes | [QList][QList]&lt;int&gt; | A list of sizes for the partitions. The total number of partitions is equal to the length of this list. Each value in this list specifies the number of [Mats][Mat] that should be in each template of the associated partition. The sum of values in this list *must* equal the number of [Mats][Mat] in each [Template](../template/template.md) in the original [TemplateList](templatelist.md).
+
+* **output:** ([QList][QList]&lt;[TemplateList](templatelist.md)&gt;) Returns a [QList][QList] of [TemplateLists](templatelist.md) of partitions. Each partition has length equal to the number of templates in the original [TemplateList](templatelist.md). Each [Template](../template/template.md) has length equal to the size specified in the associated value in **partitionSizes**.
+* **example:**
+
+        Template t1, t2, t3;
+
+        t1.append(Mat::ones(1, 1, CV_8U));
+        t1.append(2*Mat::ones(1, 1, CV_8U));
+        t1.append(3*Mat::ones(1, 1, CV_8U));
+
+        t2.append(4*Mat::ones(1, 1, CV_8U));
+        t2.append(5*Mat::ones(1, 1, CV_8U));
+        t2.append(6*Mat::ones(1, 1, CV_8U));
+
+        t3.append(7*Mat::ones(1, 1, CV_8U));
+        t3.append(8*Mat::ones(1, 1, CV_8U));
+        t3.append(9*Mat::ones(1, 1, CV_8U));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3);
+
+        QList<TemplateList> partitions = tList.partition(QList<int>() << 1 << 2); // split into 2 partitions. 1 with 1 Mat and 1 with 2 Mats.
+
+        partitions[0]; // returns [("1"), ("4"), ("7")]
+        partitions[1]; // returns [("2", "3"), ("5", "6"), ("8", "9")]
+
+## [FileList](../filelist/filelist.md) files() const {: #files }
+
+Get a list of all the [Files](../file/file.md) in the [TemplateList](templatelist.md)
+
+* **function definition:**
+
+        FileList files() const
+
+* **parameters:** NONE
+* **output:** ([FileList](../filelist/filelist.md)) Returns a [FileList](../filelist/filelist.md) with the [file](../template/members.md#file) of each [Template](../template/template.md) in the [TemplateList](templatelist.md).
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+
+        t1.file.set("Key", QVariant::fromValue<float>(1));
+        t2.file.set("Key", QVariant::fromValue<float>(2));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+
+        tList.files(); // returns ["picture1.jpg[Key=1]", "picture2.jpg[Key=2]"]
+
+
+## [FileList](../filelist/filelist.md) operator()() {: #operator-pp }
+
+Shortcut call to [files](#files)
+
+* **function definition:**
+
+        FileList operator()() const
+
+* **parameters:** NONE
+* **output:** ([FileList](../filelist/filelist.md)) Returns a [FileList](../filelist/filelist.md) with the [file](../template/members.md#file) of each [Template](../template/template.md) in the [TemplateList](templatelist.md).
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+
+        t1.file.set("Key", QVariant::fromValue<float>(1));
+        t2.file.set("Key", QVariant::fromValue<float>(2));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+
+        tList.files(); // returns ["picture1.jpg[Key=1]", "picture2.jpg[Key=2]"]
+
+
+## [QMap][QMap]&lt;T, int&gt; countValues(const [QString][QString] &propName, bool excludeFailures = false) const {: #countvalues }
+
+Get the frequency of each unique value associated with a provided [metadata](../file/members.md#m_metadata) key.
+
+* **function definition:**
+
+template<typename T> QMap<T,int> countValues(const QString &propName, bool excludeFailures = false) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    propName | const [QString][QString] & | [Metadata](../file/members.md#m_metadata) key
+    excludeFailures | bool | (Optional) Exclude [File](../file/file.md) [metadata](../file/members.md#m_metadata) if the [File](../file/file.md) has [fte](../file/members.md#fte) equal to true. Default is false
+
+* **output:** ([QMap][QMap]&lt;<T, int&gt;) Returns a mapping between unique [metadata](../file/members.md#m_metadata) and their frequency.
+* **example:**
+
+        Template t1, t2, t3, t4;
+
+        t1.file.set("Key", QString("Class 1"));
+        t2.file.set("Key", QString("Class 2"));
+        t3.file.set("Key", QString("Class 3"));
+        t4.file.set("Key", QString("Class 1"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3 << t4);
+
+        tList.countValues<QString>("Key"); // returns QMap(("Class 1", 2), ("Class 2", 1), ("Class 3", 1))
+
+## [TemplateList](templatelist.md) reduced() const {: #reduced }
+
+Reduce the [Templates](../template/template.md) in the [TemplateList](templatelist.md) by merging them together.
+
+* **function definition:**
+
+        TemplateList reduced() const
+
+* **parameters:** NONE
+* **output:** ([TemplateList](templatelist.md)) Returns a [TemplateList](templatelist.md) with a single [Template](../template/template.md). The [Template](../template/template.md) is the result of calling [merge](../template/functions.md#merge) on every [Template](../template/template.md).
+* **see:** [merge](../template/functions.md#merge)
+* **example:**
+
+        Template t1("picture1.jpg"), t2("picture2.jpg");
+
+        t1.file.set("Key1", QString("Value1"));
+        t2.file.set("Key2", QString("Value2"));
+
+        TemplateList tList(QList<Template>() << t1 << t2);
+
+        TemplateList reduced = tList.reduced();
+        reduced.size(); // returns 1
+        reduced.files(); // returns ["picture1.jpg;picture2.jpg[Key1=Value1, Key2=Value2, separator=;]"]
+
+## [QList][QList]&lt;int&gt; find(const [QString][QString] &key, const T &value) {: #find }
+
+Get the indices of every [Template](../template/template.md) that has a provided key value pairing in its [metadata](../file/members.md#m_metadata)
+
+* **function definition:**
+
+        template<typename T> QList<int> find(const QString &key, const <tt>T</tt> &value)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    key | const [QString][QString] & | [Metadata](../file/members.md#m_metadata) key to search for
+    value | const <tt>T</tt> & | Value to search for. Both the **key** and value must match. <tt>T</tt> is a user specified type.
+
+* **output:** ([QList][QList]&lt;int&gt;) Returns a list of indices for [Templates](../template/template.md) that contained the key-value pairing in their [metadata](../file/members.md#m_metadata)
+* **example:**
+
+        Template t1, t2, t3;
+
+        t1.file.set("Key", QString("Value1"));
+        t2.file.set("Key", QString("Value2"));
+        t3.file.set("Key", QString("Value2"));
+
+        TemplateList tList(QList<Template>() << t1 << t2 << t3);
+        tList.find<QString>("Key", "Value2"); // returns [1, 2]
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QHash]: http://doc.qt.io/qt-5/qhash.html "QHash"
+[QMap]: http://doc.qt.io/qt-5/qmap.html "QMap"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QVariant]: http://doc.qt.io/qt-5/qvariant.html "QVariant"
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+## [TemplateList](templatelist.md) fromGallery(const [File](../file/file.md) &gallery) {: #fromgallery }
+
+Create a [TemplateList](templatelist.md) from a gallery [File](../file/file.md).
+
+* **function definition:**
+
+        static TemplateList fromGallery(const File &gallery)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    gallery | const [File](../file/file.md) & | Gallery [file](../file/file.md) to be enrolled.
+
+* **output:** ([TemplateList](templatelist.md)) Returns a [TemplateList](templatelist.md) created by enrolling the gallery.
+
+
+## [TemplateList](templatelist.md) fromBuffer(const [QByteArray][QByteArray] &buffer) {: #frombuffer }
+
+Create a template from a memory buffer of individual templates. This is compatible with **.gal** galleries.
+
+* **function definition:**
+
+        static TemplateList fromBuffer(const QByteArray &buffer)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    buffer | const [QByteArray][QByteArray] & | Raw data buffer to be enrolled
+
+* **output:** ([TemplateList](templatelist.md)) Returns a [TemplateList](templatelist.md) created by enrolling the buffer
+
+
+## [TemplateList](templatelist.md) relabel(const [TemplateList](templatelist.md) &tl, const [QString][QString] &propName, bool preserveIntegers) {: #relabel }
+
+Relabel the values associated with a given key in the [metadata](../file/members.md#m_metadata) of a provided [TemplateList](templatelist.md). The values are relabeled to be between [0, numClasses-1]. If preserveIntegers is true and the [metadata](../file/members.md#m_metadata) can be converted to integers then numClasses equals the maximum value in the values. Otherwise, numClasses equals the number of unique values. The relabeled values are stored in the "Label" field of the returned [TemplateList](templatelist.md).
+
+* **function definition:**
+
+        static TemplateList relabel(const TemplateList &tl, const QString &propName, bool preserveIntegers)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    tl | const [TemplateList](templatelist.md) & | [TemplateList](templatelist.md) to be relabeled
+    propName | const [QString][QString] & | [Metadata](../file/members.md#m_metadata) key
+    preserveIntegers | bool | If true attempt to use the [metadata](../file/members.md#m_metadata) values as the relabeled values. Otherwise use the number of unique values.
+
+* **output:** ([TemplateList](templatelist.md)) Returns a [TemplateList](templatelist.md) identical to the input [TemplateList](templatelist.md) but with the new labels appended to the [metadata](../file/members.md#m_metadata) using the "Label" key.
+* **example:**
+
+        Template t1, t2, t3;
+
+        t1.file.set("Class", QString("1"));
+        t2.file.set("Class", QString("10"));
+        t3.file.set("Class", QString("100"));
+        TemplateList tList(QList<Template>() << t1 << t2 << t3);
+
+        TemplateList relabeled = TemplateList::relabel(tList, "Class", true);
+        relabeled.files(); // returns [[Class=1, Label=1], [Class=10, Label=10], [Class=100, Label=100]]
+
+        relabeled = TemplateList::relabel(tList, "Class", false);
+        relabeled.files(); // returns [[Class=1, Label=0], [Class=10, Label=1], [Class=100, Label=2]]
+
+<!-- Links -->
+[QByteArray]: http://doc.qt.io/qt-5/qbytearray.html "QByteArray"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+<!-- TEMPLATELIST -->
+
+Inherits [QList][QList]&lt;[Template](../template/template.md)&gt;.
+
+Convenience class for working with a list of templates.
+
+See:
+
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+<!-- Links -->
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+Constructor | Description
+--- | ---
+TimeVaryingTransform(bool independent = true, bool trainable = true) | Default constructor. Calls [Transform](../transform/transform.md) [constructor](../transform/constructors.md) with the given value of [independent](../transform/members.md#independent) and [trainable](../transform/members.md#trainable). It also initializes [timeInvariantAlias](members.md#timeinvariantalias).
+## bool timeVarying() {: #timevarying }
+
+This is a virtual function. Check if the transform is time varying. This always evaluates to true.
+
+* **function definition:**
+
+        virtual bool timeVarying() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns true (the transform is always time varying)
+
+## void project(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #project-1 }
+
+This is a virtual function. For [TimeVaryingTransforms](timevaryingtransform.md) normal enrollment calls [projectUpdate](#projectupdate-2). It is still possible to call this version of project instead but it must be done explicitly and is **strongly** discouraged. If this function is called [timeInvariantAlias](members.md#timeinvariantalias) is used to call [projectUpdate](#projectupdate-2) in a thread safe way.
+
+* **function definition:**
+
+        virtual void project(const Template &src, Template &dst) const
+
+ * **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | The input template
+    dst | [Template](../template/template.md) & | The output template
+
+* **output:** (void)
+
+## void project(const [TemplateList](../templatelist/templatelist.md) &src, [TemplateList](../templatelist/templatelist.md) &dst) {: #project-2 }
+
+This is a virtual function. For [TimeVaryingTransforms](timevaryingtransform.md) normal enrollment calls [projectUpdate](#projectupdate-2). It is still possible to call this version of project instead but it must be done explicitly and is **strongly** discouraged. If this function is called [timeInvariantAlias](members.md#timeinvariantalias) is used to call [projectUpdate](#projectupdate-2) in a thread safe way.
+
+* **function definition:**
+
+        virtual void project(const TemplateList &src, TemplateList &dst) const
+
+ * **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [TemplateList](../templatelist/templatelist.md) & | The input template list
+    dst | [TemplateList](../templatelist/templatelist.md) & | The output template list
+
+* **output:** (void)
+
+## void projectUpdate(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #projectupdate-1 }
+
+This is a virtual function. This function should never be called because it is useless to implement a Template -> Template call using project update. An error is thrown if it is called.
+
+* **function definition:**
+
+        virtual void projectUpdate(const Template &src, Template &dst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | The input template
+    dst | [Template](../template/template.md) & | The output template
+
+* **output:** (void)
+
+## void projectUpdate(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #projectupdate-1 }
+
+This is a virtual function. This function should never be called because it is useless to implement a Template -> Template call using project update. An error is thrown if it is called.
+
+* **function definition:**
+
+        virtual void projectUpdate(const Template &src, Template &dst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | The input template
+    dst | [Template](../template/template.md) & | The output template
+
+* **output:** (void)
+
+## void projectUpdate(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #projectupdate-1 }
+
+This is a virtual function. This function should never be called because it is useless to implement a Template -> Template call using project update. An error is thrown if it is called.
+
+* **function definition:**
+
+        virtual void projectUpdate(const Template &src, Template &dst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | The input template
+    dst | [Template](../template/template.md) & | The output template
+
+* **output:** (void)
+
+## void projectUpdate(const [TemplateList](../templatelist/templatelist.md) &src, [TemplateList](../templatelist/templatelist.md) &dst) {: #projectupdate-2 }
+
+This is a virtual function. This is the non-const alternative to [project](../transform/functions.md#project-1). It allows the internal state of the transform to be update at project time.
+
+* **function definition:**
+
+        virtual void projectUpdate(const TemplateList &src, TemplateList &dst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [TemplateList](../templatelist/templatelist.md) & | The input template list
+    dst | [TemplateList](../templatelist/templatelist.md) & | The output template list
+
+* **output:** (void)
+
+## [Transform](../transform/transform.md) \*smartCopy(bool &newTransform) {: #smartcopy }
+
+This is a virtual function. Make a smart copy of the transform.
+
+* **function definition:**
+
+        virtual Transform *smartCopy(bool &newTransform)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    newTransform | bool & | True if a new, simplified, transform was allocated inside this call, false otherwise
+
+* **output:** ([Transform](../transform/transform.md) \*) Returns a copy of itself by default. newTransform is set to true in this case.
+Members | Type | Description
+--- | --- | ---
+<a class="table-anchor" id="timeinvariantalias"></a> timeInvariantAlias | TimeInvariantWrapperTransform | A special case helper class that ensures usually thread safe calls like [project](../transform/functions.md#project-1) can be called non-thread safe objects. In a very simplified description, this calls [projectUpdate](functions.md#projectupdate-1) instead of [project](functions.md#project-1)
+Inherits [Transform](../transform/transform.md)
+
+A [Transform](../transform/transform.md) that can change state at project time.
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Functions](functions.md)
+
+TimeVaryingTransforms are [Transforms](../transform/transform.md) that need to change their state at project time. This is opposed to [Transforms](../transform/transform.md) which can only change state at train time. Common examples include video processing across multiple frames, aggregate projection statistics etc.
+Constructor / Destructor | Description
+--- | ---
+Transform(bool independent = true, bool trainable = true) | Default constructor for transforms. By default [independent](members.md#independent) and [trainable](members.md#trainable) are set to true.
+~Transform() | Default Destructor, it doesn't do anything
+## [Transform](transform.md) \*clone() {: #clone }
+
+This is a virtual function. Make a deep copy of the transform.
+
+* **function definition:**
+
+        virtual Transform *clone() const
+
+* **parameters:** NONE
+* **output:** ([Transform](transform.md))
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            Q_PROPERTY(int property READ get_property WRITE set_property RESET reset_property STORED false)
+            BR_PROPERTY(int, property, 1)
+
+            ...
+        };
+
+        Transform *transform = Transform::make("Example", NULL);
+        transform->parameters(); // returns ["property = 1"]
+
+        Transform *clone = transform->clone();
+        clone->parameters(); // returns ["property = 1"]
+
+        transform->setProperty("property", 10);
+        transform->parameters(); // returns ["property = 10"]
+        clone->parameters(); // returns ["property = 1"]
+
+
+## void train(const [TemplateList](../templatelist/templatelist.md) &data) {: #train-1 }
+
+This is a virtual function. Train the transform on provided training data. This function should be overloaded for any transform that needs to be trained. [Trainable](members.md#trainable) must be set to true for this function to be called. If [independent](members.md#independent) is true a new instance of the transform will be trained for each [Mat][Mat] stored in a [Template](../template/template.md) in the provided training data. Each [Template](../template/template.md) should have the same number of [Mats][Mat].
+
+* **function definition:**
+
+        virtual void train(const TemplateList &data)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    data | const [TemplateList](../templatelist/templatelist.md) & | Training data. The format of the data depends on the transform to be trained. In some cases the transform requires a "Label" field in each [Template](../template/template.md) [file's](../template/members.md#file) [metadata](../file/members.md#m_metadata) (normally these are classifiers like [SVM](../../../plugin_docs/classification.md#svmtransform)). In other cases no metadata is required and training occurs on the raw image data only.
+
+* **output:** (void)
+* **example:**
+
+        // Create data for a 2-class classification problem
+        Template t1("training_pic1.jpg");
+        t1.file.set("Label", 0);
+        Template t2("training_pic2.jpg");
+        t2.file.set("Label", 0);
+        Template t3("training_pic3.jpg");
+        t3.file.set("Label", 1);
+        Template t4("training_pic4.jpg");
+        t4.file.set("Label", 1);
+
+        TemplateList training_data(QList<Template>() << t1 << t2 << t3 << t4);
+
+        Transform *classifier = Transform::make("DataPrep+Classifier");
+        classifier->train(training_data); // The data is projected through DataPrep, assuming it is untrainable, and then passed to the train method of Classifier
+
+
+## void train(const [QList][QList]&lt;[TemplateList](../templatelist/templatelist.md)&gt; &data) {: #train-2 }
+
+This is a virtual function. This version of train is meant for special-case, internal, transforms and for tranforms that require a specific number of templates at project time. If a transform requires a specific number of templates at project time it should be trained in batches that have the same number of templates. For example, if a transform requires exactly 5 templates when projecting it should get a list of [TemplateLists](../templatelist/templatelist.md), each with exactly 5 templates, at train time. Each [TemplateList](../templatelist/templatelist.md) can then be treated as an individual input to the training function.
+
+* **function definition:**
+
+    virtual void train(const QList<TemplateList> &data)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    data | const [QList][QList]&lt;[TemplateList](../templatelist/templatelist.md)&gt; & | Specially formatted list of training input. Format should match what is passed to [project](#project-2).
+
+* **output:** (void)
+
+
+## void project(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #project-1 }
+
+This is a pure virtual function. It must be overloaded by all derived classes. Project a template through the transform, modifying its contents in some way and storing the modified data in **dst**. This function has a strict [Template](../template/template.md) in, [Template](../template/template.md) out model. For a multiple [Template](../template/template.md) in, multiple [Template](../template/template.md) out model see [project]{: #project-2 }.
+
+* **function definition:**
+
+        virtual void project(const Template &src, Template &dst) const = 0
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | Input template. It is immutable
+    dst | [Template](../template/template.md) & | Output template. Should contain the modified data from the input template.
+
+* **output:** (void)
+* **example:**
+
+        Template src("color_picture.jpg"), dst;
+
+        Transform *color_converter = Transfrom::make("Read+Cvt(Gray)");
+        color_converter->project(src, dst); // returns a grayscale image stored in dst
+
+
+## void project(const [TemplateList](../templatelist/templatelist.md) &src, [TemplateList](../templatelist/templatelist.md) &dst) {: #project-2 }
+
+This is a virtual function. Project multiple [Templates](../template/template.md) in and get multiple, modified, [Templates](../template/template.md) out. Especially useful in cases like detection where the requirement is image in, multiple objects out. The default implementation calls [project](#project-1) on each [Template](../template/template.md) in **src** and appends the results to **dst**.
+
+* **function definition:**
+
+        virtual void project(const TemplateList &src, TemplateList &dst) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [TemplateList](../templatelist/templatelist.md) & | Input templates. It is immutable
+    dst | [TemplateList](../templatelist/templatelist.md) & | Output templates. Should contain the modified data from the input templates
+
+* **output:** (void)
+* **example:**
+
+        TemplateList src(QList<Template>() << Template("image_with_faces.jpg")), dst;
+
+        Transform *face_detector = Transform::make("FaceDetector");
+        face_detector->project(src, dst); // dst will have one template for every face detected in src
+
+
+## void projectUpdate(const [Template](../template/template.md) &src, [Template](../template/template.md) &dst) {: #projectupdate-1 }
+
+This is a virtual function. Very similar to [project](#project-1) except this version is not **const** and can modify the internal state of the transform.
+
+* **function definition:**
+
+        virtual void projectUpdate(const Template &src, Template &dst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | Input template. It is immutable
+    dst | [Template](../template/template.md) & | Output template. Should contain the modified data from the input template.
+
+* **output:** (void)
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            int internalState;
+
+            void projectUpdate(const Template &src, Template &dst)
+            {
+                dst = src;
+                internalState++;
+            }
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        Template src("picture.jpg"), dst;
+
+        Transform *example = Transform::make("Example");
+        example->projectUpdate(src, dst); // dst is unchanged but Example's internalState has been incremented.
+
+
+## void projectUpdate(const [TemplateList](../templatelist/templatelist.md) &src, [TemplateList](../templatelist/templatelist.md) &dst) {: #projectupdate-2 }
+
+This is a virtual function. Very similar to [project](#project-2) except this version is not **const** and can modify the internal state of the transform.
+
+* **function definition:**
+
+        virtual void projectUpdate(const TemplateList &src, TemplateList &dst)
+
+* **parameters:**
+
+        Parameter | Type | Description
+        --- | --- | ---
+        src | const [TemplateList](../templatelist/templatelist.md) & | Input templates. It is immutable
+        dst | [TemplateList](../templatelist/templatelist.md) & | Output templates. Should contain the modified data from the input templates
+
+* **output:** (void)
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            int internalState;
+
+            void projectUpdate(const TemplateList &src, TemplateList &dst)
+            {
+                dst = src;
+                internalState++;
+            }
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        TemplateList src(QList<Template>() << Template("picture.jpg")), dst;
+
+        Transform *example = Transform::make("Example");
+        example->projectUpdate(src, dst); // dst is unchanged but Example's internalState has been incremented.
+
+
+## void projectUpdate([Template](../template/template.md) &srcdst) {: #projectupdate-3 }
+
+In-place version of [projectUpdate](#projectupdate-1).
+
+* **function definition:**
+
+        void projectUpdate(Template &srcdst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    srcdst | [Template](../template/template.md) & | Input and output template. It is overwritten with the output value after projecting
+
+* **output:** (void)
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            int internalState;
+
+            void projectUpdate(const Template &src, Template &dst)
+            {
+                dst = src;
+                internalState++;
+            }
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        Template src("picture.jpg");
+
+        Transform *example = Transform::make("Example");
+        example->projectUpdate(src); // src is modified in-place and Example's internalState has been incremented.
+
+
+## void projectUpdate([TemplateList](../templatelist/templatelist.md) &srcdst) {: #projectupdate-4 }
+
+In-place version of [projectUpdate](#projectupdate-2).
+
+* **function definition:**
+
+        void projectUpdate(TemplateList &srcdst)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    srcdst | [TemplateList](../templatelist/templatelist.md) & | Input and output templates. It is overwritten with the output value after projecting
+
+* **output:** (void)
+* **example:**
+
+        class ExampleTransform : public Transform
+        {
+            Q_OBJECT
+
+            int internalState;
+
+            void projectUpdate(const TemplateList &src, TemplateList &dst)
+            {
+                dst = src;
+                internalState++;
+            }
+
+            ...
+        };
+
+        BR_REGISTER(Transform, ExampleTransform)
+
+        TemplateList src(QList<Template>() << Template("picture.jpg"));
+
+        Transform *example = Transform::make("Example");
+        example->projectUpdate(src); // src is modified in-place and Example's internalState has been incremented.
+
+
+## bool timeVarying() {: #timevarying }
+
+This is a virtual function. Check if the transform is time varying. Time varying means the internal state of the transform needs to be updated during projection. Time varying transforms should overload this function to return true and implement [projectUpdate](#projectupdate-1) instead of [project](#project-1).
+
+* **function definition:**
+
+        virtual bool timeVarying() const
+
+* **parameters:** NONE
+* **output:** (bool) Returns true if the transform is time varying and false otherwise
+
+
+## [Template](../template/template.md) operator()(const [Template](../template/template.md) &src) {: #operator-pp-1 }
+
+A convenience function to call [project](#project-1)
+
+* **function definition:**
+
+        inline Template operator()(const Template &src) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [Template](../template/template.md) & | Input template. It is immutable.
+
+* **output**: ([Template](../template/template.md)) Returns the result of calling [project](#project-1)
+* **example:**
+
+        Template src("color_picture.jpg");
+
+        Transform *color_converter = Transfrom::make("Read+Cvt(Gray)");
+        Template dst = color_converter(src); // returns a grayscale image
+
+
+## [TemplateList](../templatelist/templatelist.md) operator()(const [TemplateList](../templatelist/templatelist.md) &src) {: #operator-pp-2 }
+
+A convenience function to call [project](#project-2)
+
+* **function definition:**
+
+        inline TemplateList operator()(const TemplateList &src) const
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    src | const [TemplateList](../templatelist/templatelist.md) & | Input templates. It is immutable.
+
+* **output**: ([TemplateList](../templatelist/templatelist.md)) Returns the result of calling [project](#project-2)
+* **example:**
+
+        TemplateList src(QList<Template>() << Template("color_picture.jpg"));
+
+        Transform *color_converter = Transfrom::make("Read+Cvt(Gray)");
+        TemplateList dst = color_converter(src); // returns a list of grayscale images
+
+
+## [Transform](transform.md) \*smartCopy(bool &newTransform) {: #smartcopy-1 }
+
+This is a virtual function. Only [TimeVaryingTransforms](../timevaryingtransform/timevaryingtransform.md) need to overload this method. Similar to [clone](#clone), this function returns a deep copy of the transform. Unlike [clone](#clone), which copies everything, this function should copy the minimum amount required so that [projectUpdate](#projectupdate-1) can be called safely on the original instance and the copy returned by this function concurrently.
+
+* **function definition:**
+
+        virtual Transform *smartCopy(bool &newTransform)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    newTransform | bool & | True if the returned transform is newly allocated, false otherwise. This is used to handle deallocation. If newTransform is true, the caller of this function is responsible for deallocating it. If not, a [QSharedPointer][QSharedPointer] can wrap the output, and it will be deallocated elsewhere.
+
+* **output:** ([Transform](transform.md) \*) Returns a pointer to a deep, smart, copy of the transform
+
+
+## [Transform](transform.md) \*smartCopy() {: #smartcopy-2 }
+
+Convenience function to call [smartCopy](#smartcopy-1) without arguments
+
+* **function definition:**
+
+        virtual Transform *smartCopy()
+
+* **parameters:** NONE
+* **output:** ([Transform](transform.md) \*) Returns a pointer, to a deep, smart, copy of the transform
+
+
+## [Transform](transform.md) \*simplify(bool &newTransform) {: #simplify }
+
+This is a virtual function. Get a simplified version of the transform for use at project time. The simplified version of the [Transform](transform.md) does not include any [Transforms](transform.md) that are only active at train time. It also removes any [LoadStore](../../../plugin_docs/core.md#loadstoretransform) transforms and keeps only their children. Transforms that only are active at train time (see [DownsampleTrainingTransform](../../../plugin_docs/core.md#downsampletrainingtransform) as an example) should overload this function and return their children if they have any or NULL if they do not.
+
+* **function definition:**
+
+        virtual Transform * simplify(bool &newTransform)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    newTransform | bool & | True if the simplified transform is newly allocated, false otherwise. If true, the caller of this function is responsible for deallocating the transform.
+
+* **output:** ([Transform](transform.md) \*) Returns a pointer to the simplified version of the transform
+* **example:**
+
+        Transform *transform = Transform::make("DataProcessing+DownsampleTraining(Example)+<ModelFile>");
+        transfrom->description(); // returns "DataProcessing+DownsampleTraining(Example)+LoadStore(transformString=TransformFromModelFile)"
+
+        bool newTransform;
+        transform->simplify(newTransform)->description(); // returns "DataProcessing+Example+TransformFromModelFile"
+
+
+## [Transform](transform.md) \*make(const [QString][QString] &description) {: #make }
+
+This is a protected function. Makes a child transform from a provided description by calling [make](statics.md#make) with parent = <tt>this</tt>.
+
+* **function definition:**
+
+        inline Transform *make(const QString &description)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    description | const [QString][QString] & | Description of the child transform
+
+* **output:** ([Transform](transform.md) \*) Returns a pointer to the created child transform
+
+<!-- Links -->
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+[QList]: http://doc.qt.io/qt-5/QList.html "QList"
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QSharedPointer]: http://doc.qt.io/qt-5/qsharedpointer.html "QSharedPointer"
+Member | Type | Description
+--- | --- | ---
+<a class="table-anchor" id=independent></a>independent | bool | True if the transform is independent, false otherwise. Independent transforms process each [Mat][Mat] in a [Template](../template/template.md) independently. This means that a new instance of the transform is created for each [Mat][Mat]. If the transform is [trainable](#trainable) and the training data has more then one [Mat][Mat] per template, each created instance of the transform is trained separately. Please see [Training Algorithms](../../../tutorials.md#training-algorithms) for more details.
+<a class="table-anchor" id=trainable></a>trainable | bool | True if the transform is trainable, false otherwise. Trainable transforms need to overload the [train](functions.md#train-1) function.
+
+<!-- Links -->
+[Mat]: http://docs.opencv.org/modules/core/doc/basic_structures.html#mat "Mat"
+## [Transform](transform.md) \*make([QString][QString] str, [QObject][QObject] \*parent) {: #make }
+
+Make a transform from a string. This function converts the abbreviation characters **+**, **/**, **{}**, **<\>**, and **()** into their full-length alternatives.
+
+Abbreviation | Translation
+--- | ---
+\+ | [PipeTransform](../../../plugin_docs/core.md#pipetransform). Each [Transform](transform.md) linked by a **+** is turned into a child of a single [PipeTransform](../../../plugin_docs/core.md#pipetransform). "Example1+Example2" becomes "Pipe([Example1,Example2])". [Templates](../template/template.md) are projected through the children of a pipe in series, the output of one become the input of the next.
+/ | [ForkTransform](../../../plugin_docs/core.md#forktransform). Each [Transform](transform.md) linked by a **/** is turned into a child of a single [ForkTransform](../../../plugin_docs/core.md#forktransform). "Example1/Example2" becomes "Fork([Example1,Example2])". [Templates](../template/template.md) are projected the children of a fork in parallel, each receives the same input and the outputs are merged together.
+\{\} | [CacheTransform](../../../plugin_docs/core.md#cachetransform). Can only surround a single [Transform](transform.md). "{Example}" becomes "Cache(Example)". The results of a cached [Transform](transform.md) are stored in a global cache using the [file](../object/members.md#file) name as a key.
+<> | [LoadStoreTransform](../../../plugin_docs/core.md#loadstoretransform). Can only surround a single [Transform](transform.md). "<Example>" becomes "LoadStore(Example)". Serialize and store a [Transform](transform.md) after training or deserialize and load a [Transform](transform.md) before projecting.
+() | Order of operations. Change the order of operations using parantheses.
+
+The parsed string is then passed to [Factory](../factory/factory.md)::[make](../factory/statics.md#make) to be turned into a transform.
+
+* **function definition:**
+
+        static Transform *make(QString str, QObject *parent)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    str | [QString][QString] | String describing the transform
+    parent | [QObject][QObject] \* | Parent of the object to be created
+
+* **output:** ([Transform](transform.md) \*) Returns a pointer to the [Transform](transform.md) described by the string
+* **see:** [Factory::make](../factory/statics.md#make)
+* **example:**
+
+        Transform::make("Example1+Example2+<ModelFile>")->description(); // returns "Pipe(transforms=[Example1,Example2,LoadStore(ModelFile)])".
+
+
+## [QSharedPointer][QSharedPointer]&lt;[Transform](transform.md)&gt; fromAlgorithm(const [QString][QString] &algorithm, bool preprocess=false) {: #fromalgorithm }
+
+Create a [Transform](transform.md) from an OpenBR algorithm string. The [Transform](transform.md) is created using everything to the left of a **:** or a **!** in the string.
+
+* **function definition:**
+
+        static QSharedPointer<Transform> fromAlgorithm(const QString &algorithm, bool preprocess=false)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    algorithm | const [QString][QString] & | Algorithm string to construct the [Transform](transform.md) from
+    preprocess | bool | (Optional) If true add a [StreamTransform](../../../plugin_docs/core.md#streamtransform) as the parent of the constructed [Transform](transform.md). Default is false.
+
+* **output:** ([QSharedPointer][QSharedPointer]&lt;[Transform](transform.md)&gt;) Returns a pointer to the [Transform](transform.md) described by the algorithm.
+* **example:**
+
+    Transform::fromAlgorithm("EnrollmentTransform:Distance")->decription(); // returns "EnrollmentTransform"
+    Transform::fromAlgorithm("EnrollmentTransform!DistanceTransform")->decription(); // returns "EnrollmentTransform"
+    Transform::fromAlgorithm("EnrollmentTransform")->decription(); // returns "EnrollmentTransform"
+
+## [QSharedPointer][QSharedPointer]<[Transform](transform.md)> fromComparison(const [QString][QString] &algorithm) {: #fromcomparison }
+
+Create a[Transform](transform.md) from an OpenBR algorithm string. The [Transform](transform.md) is created using everything to the right of a **:** or a **!** in the string. If the separating symbol is a **:** the string to the right describes a distance. It is converted to a [GalleryCompareTransform](../../../plugin_docs/core.md#gallerycomparetransform) with the distance stored as a property. If the separating symbol is a **!** the string already describes a transform and is unchanged.
+
+* **function definition:**
+
+        static QSharedPointer<Transform> fromComparison(const QString &algorithm)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    algorithm | const [QString][QString] & | Algorithm string to construct the [Transform](transform.md) from
+
+* **output:** ([QSharedPointer][QSharedPointer]&lt;[Transform](transform.md)&gt;) Returns a pointer to the [Transform](transform.md) described by the algorithm.
+* **example:**
+
+        Transform::fromAlgorithm("EnrollmentTransform:Distance")->description(); // returns "GalleryCompare(distance=Distance)""
+        Transform::fromAlgorithm("EnrollmentTransform!DistanceTransform"); // returns "DistanceTransform"
+
+
+## [Transform](transform.md) \*deserialize([QDataStream][QDataStream] &stream) {: #deserialize }
+
+Deserialize a [Transform](transform.md) from a stream.
+
+* **function definition:**
+
+        static Transform *deserialize(QDataStream &stream)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | Stream containing the serialized transform
+
+* **output:** ([Transform](transform.md) \*) Returns the deserialized transform
+
+
+## [Template](../template/template.md) &operator&gt;&gt;([Template](../template/template.md) &srcdst, const [Transform](transform.md) &f) {: #template-operater-gtgt-1 }
+
+Convenience function for [project](functions.md#project-1)
+
+* **function definition:**
+
+        inline Template &operator>>(Template &srcdst, const Transform &f)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    srcdst | [Template](../template/template.md) & | Input template. Will be overwritten with the output following call to [project](functions.md#project-1)
+    f | const [Transform](transform.md) & | [Transform](transform.md) to project through.
+
+* **output:** ([Template](../template/template.md) &) Returns the output of f::[project](functions.md#project-1)
+* **example:**
+
+        Template t("picture1.jpg");
+        Transform *transform = Transform::make("Example", NULL);
+
+        t >> *transform; // projects t through Example. t is overwritten with the output of the project call
+
+<!--no italics* -->
+
+## [TemplateList](../templatelist/templatelist.md) &operator&gt;&gt;([TemplateList](../templatelist/templatelist.md) &srcdst, const [Transform](transform.md) &f) {: #template-operater-gtgt-2 }
+
+Convenience function for [project](functions.md#project-2)
+
+* **function definition:**
+
+        inline TemplateList &operator>>(TemplateList &srcdst, const Transform &f)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    srcdst | [TemplateList](../templatelist/templatelist.md) & | Input templates. Will be overwritten with the output following call to [project](functions.md#project-2)
+    f | const [Transform](transform.md) & | [Transform](transform.md) to project through.
+
+* **output:** ([TemplateList](../templatelist/templatelist.md) &) Returns the output of f::[project](functions.md#project-2)
+* **example:**
+
+        TemplateList tList(QList<Template>() << Template("picture1.jpg"));
+        Transform *transform = Transform::make("Example", NULL);
+
+        tList >> *transform; // projects tList through Example. tList is overwritten with the output of the project call
+
+<!--no italics* -->
+
+## [QDataStream][QDataStream] &operator&lt;&lt;([QDataStream][QDataStream] &stream, const [Transform](transform.md) &f) {: #stream-operator-ltlt}
+
+Convenience function for [store](../object/functions.md#store)
+
+* **function definition:**
+
+        inline QDataStream &operator<<(QDataStream &stream, const Transform &f)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | Stream to store the transform in
+    f | const [Transform](transform.md) & | Transform to be stored
+
+* **output:** ([QDataStream][QDataStream] &) Returns the stream with the transform stored in it
+* **example:**
+
+        Transform *transform = Transform::make("Example(property1=value1,property2=value2)");
+
+        QDataStream stream;
+        stream << *transform; // stores "Example(property1=value1,property2=value2)" in the stream
+
+<!--no italics* -->
+
+## [QDataStream][QDataStream] &operator&gt;&gt;([QDataStream][QDataStream] &stream, const [Transform](transform.md) &f)  {: #stream-operator-gtgt}
+
+Convenience function for [load](../object/functions.md#load)
+
+* **function definition:**
+
+        inline QDataStream &operator>>(QDataStream &stream, const Transform &f)
+
+* **parameters:**
+
+    Parameter | Type | Description
+    --- | --- | ---
+    stream | [QDataStream][QDataStream] & | Stream to load the transform from
+    f | const [Transform](transform.md) & | Transform to store loaded information
+
+* **output:** ([QDataStream][QDataStream] &) Returns the stream without the transform data
+* **example:**
+
+        Transform *in = Transform::make("Example(property1=value1,property2=value2)");
+
+        QDataStream stream;
+        stream << *in; // stores "Example(property1=value1,property2=value2)" in the stream
+
+        Transform out;
+        stream >> out;
+        out->description(); // returns "Example(property1=value1,property2=value2)"
+
+<!-- Links -->
+[QString]: http://doc.qt.io/qt-5/QString.html "QString"
+[QObject]: http://doc.qt.io/qt-5/QObject.html "QObject"
+[QSharedPointer]: http://doc.qt.io/qt-5/qsharedpointer.html "QSharedPointer"
+[QDataStream]: http://doc.qt.io/qt-5/qdatastream.html "QDataStream"
+<!-- TRANSFORM -->
+
+Inherits [Object](../object/object.md)
+
+Plugin base class for processing a template.
+
+See:
+
+* [Members](members.md)
+* [Constructors](constructors.md)
+* [Static Functions](statics.md)
+* [Functions](functions.md)
+
+Transforms support the idea of *training* and *projecting*, whereby they are (optionally) given example images and are expected learn how to transform new instances into an alternative, hopefully more useful, basis for the recognition task at hand. Transforms can be chained together to support the declaration and use of arbitrary algorithms at run time.